Next video will be on embeddings and hopefully done soon-ish.

To answer your question:

EECS Major in college; 20 years of engineering and product management experience. I have given a few technical talks at conferences and I do enjoy the process of explaining things though it takes a surprising amount of work.

When I went to school ironically neural nets were the one thing they didn't cover in the intro to AI courses. I've basically learned modern AI from just filling my own curiosity over the years through online resources on nights and weekends. Learned a lot from Jeremy Howard's Fast.ai and Andrej Karpathy's stuff just like everyone else. I really wanted to know how every step of GPT worked, kind of like how you learn Computer Architecture in college: you learn how CPUs work in principle starting with circuits. Then I got a crazy idea the whole model could fit in a spreadsheet because well I just really like spreadsheets. Went down a 2-3 month rabbit hole in my non-existent sparetime to make it work.

I'm so happy to hear that I had some part to play in inspiring such a marvellous project.

It's another reason to potentially port this thing to the browser one day... https://github.com/ianand/spreadsheets-are-all-you-need/issu...

Is RLHF even strictly necessary?

Even if URIAL works with GPT2 small, the really small context length in the Excel file as currently implemented will make it hard to leverage. I've considered a more flexible implementation to support a longer context length (e.g. using Macros to build the layout of the sheet) but have prioritized the teaching videos first.

[1] https://allenai.github.io/re-align/index.html [2] Summary https://twitter.com/intuitmachine/status/1732089266883141856

Holy color use, Batman! Someone take the crayons away from that web designer.

It was discussed here some time ago: https://news.ycombinator.com/item?id=38505211

A question for the author: will it be open sourced?

There's a GitHub link on the page: https://github.com/ianand/spreadsheets-are-all-you-need

The introduction video on the page is very nice indeed to get a basic idea on the inner working of the Excel sheet.

Like spreadsheets, domain names are a bit of an obsession for me. One of the other AI side projects I'm working on is a CustomGPT to help come up with domain names (https://niftynamer.com) so I don't have to come-up-with-another-unwieldy-long-domain-name.again.

It’s often true though. So many things I think “I could make an app for that” I wind up just using a spreadsheet for. At least it helps me explore the use cases more deeply for when I’d want to actually take it to the next level.

I hung out with a friend while they solved Advent of Code challenges in Excel, that was a trip to watch.

It sounds cool, but I'd hate to rely on it since Google will probably shut it down.

Requesting just "AppSheet" gives the right result.

You mention Excel, and a bunch of us do it Google Sheets, but at this point it's not about sheets of data anymore and more about the interface and runtime, and we have full applications running in it.

I remember a colleague running API tests inside his Excel sheet to more easily check for the different parameter combinations, but telling everyone he was still using Postman just to avoid discussing it.

https://news.ycombinator.com/item?id=26057530

https://www.cs.cmu.edu/~bam/papers/VLtax2-jvlc-1990.pdf

https://news.ycombinator.com/item?id=26061576

>Brad Myers' paper answers the age-old argument about whether or not spreadsheets are visual programming languages!

>Google sheets (and other google docs) can be programmed in "serverless" JavaScript that runs in the cloud somewhere. It's hellishly slow making sheets API calls, though. Feels like some kind of remote procedure call. (Slower than driving Excel via OLE Automation even, and that's saying something!) Then it times out on a wall clock (not cpu time) limit, and breaks if you take too long.

>A CS grad student friend of mine was in a programming language class, and the instructor was lecturing about visual programming languages, and claimed that there weren't any widely used visual programming languages. (This was in the late 80's, but some people are still under the same impression.)

>He raised his hand and pointed out that spreadsheets qualified as visual programming languages, and were pretty darn common.

>They're quite visual and popular because of their 2D spatial nature, relative and absolute 2D addressing modes, declarative functions and constraints, visual presentation of live directly manipulatable data, fonts, text attributes, background and foreground colors, lines, patterns, etc. Some even support procedural scripting languages whose statements are written in columns of cells.

>Maybe "real programmers" would have accepted spreadsheets more readily had Lotus named their product "Lotus 012"? (But then normal people would have hated it!)

>I Was Wrong About Spreadsheets And I'm Sorry:

https://www.reifyworks.com/writing/2017-01-25-i-was-wrong-ab...

Excerpt from "Taxonomies of Visual Programming and Program Visualization", by Brad A Myers, 1990/3/1, Journal of Visual Languages & Computing, Volume 1, Issue 1, pages 97-123:

Spreadsheets, such as those in VisiCalc or Lotus 1-2-3, were designed to help nonprogrammers manage finances. Spreadsheets incorporate programming features and can be made to do general purpose calculations [71] and therefore qualify as a very-high level Visual Programming Language. Some of the reasons that spreadsheets are so popular are (from [43] and [1]):

1. the graphics on the screen use familiar, concrete, and visible representation which directly maps to the user's natural model of the data,

2. they are nonmodal and interpretive and therefore provide immediate feedback,

3. they supply aggregate and high-level operations,

4. they avoid the notion of variables (all data is visible),

5. the inner world of computation is suppressed,

6. each cell typically has a single value throughout the computation,

7. they are nondeclarative and typeless,

8. consistency is automatically maintained, and

9. the order of evaluation (flow of control) is entirely derived from the declared cell dependencies.

The first point differentiates spreadsheets from many other Visual Programming Languages including flowcharts which are graphical representations derived from textual (linear) languages. With spreadsheets, the original representation in graphical and there is no natural textual language.

Action Graphics [41] uses ideas from spreadsheets to try to make it easier to program graphical animations. The 'Forms' system [43] uses a more conventional spreadsheet format, but adds sub-sheets (to provide procedural abstraction) which can have an unbounded size (to handle arbitrary parameters).

A different style of system is SIL-ICON [49], which allows the user to construct 'iconic sentences' consisting of graphics arranged in a meaningful two-dimensional fashion, as shown in Figure 5. The SIL-ICON interpreter then parses the picture to determine what it means. The interpreter itself is generated from a description of the legal pictures, in the same way that conventional compilers can be generated from BNF descriptions of the grammar.

10. Conclusions

Visual Programming and Program Visualization are interesting areas that show promise for improving the programming process, especially for non-programmers, but more work needs to be done. The success of spreadsheets demonstrates that if we find the appropriate paradigms, graphical techniques can revolutionize the way people interact with computers.

https://news.ycombinator.com/item?id=26061279

>By the way, something I always meant to ask you, Brad: How does "C32" fit into your acronym theme of gemstones and rocks? Is it a teeny tiny 4x4x2 carbon atom block of diamond? How many carats would that be?

>Brad Myers wrote several articles in that book about his work on PERIDOT and GARNET, and he also developed C32:

>C32: CMU's Clever and Compelling Contribution to Computer Science in CommonLisp which is Customizable and Characterized by a Complete Coverage of Code and Contains a Cornucopia of Creative Constructs, because it Can Create Complex, Correct Constraints that are Constructed Clearly and Concretely, and Communicated using Columns of Cells, that are Constantly Calculated so they Change Continuously, and Cancel Confusion

>Spreadsheet-like system that allows constraints on objects to be specified by demonstration. Intelligent cut and paste. Implemented using Garnet.

http://www.cs.cmu.edu/~bam/acronyms.html

https://worrydream.com/refs/Kay_1984_-_Computer_Software.pdf

> The dynamic spreadsheet is a good example of such a tissuelike superobject. It is a simulation kit, and it provides a remarkable degree of direct leverage. Spreadsheets at their best combine the genres established in the 1970's (objects, windows, what-you-see-is-what-you-get editing and goal-seeking retrieval) into a "better old thing" that is likely to be one of the "almost new things" for the mainstream designs of the next few years.

In a text based language you see the code as text

In visual programming you generally see the code as a connected graph of nodes like Unreal Blueprints

In most spreadsheets you don't see the code. it's all hidden as formulas in cells and all you see is the result of each formula.

I'm not saying a spreadsheet isn't a programming environment but it's hard to see it as "visual programming" to see at most one line at a time

Formulas tab > Formula Auditing group > Show Formulas button

Spreadsheets typically show the entire formula of the selected cell at the top of the window, at the full width of the window.

Visual programming languages based on outliners and notebooks, like UserLand Frontier, Jupyter, or Mathematica, let you hide the code by closing the outlines or code editor views.

The many lives of Frontier:

https://www.youtube.com/watch?v=MlN-L88KScw

Demo of Scripts menu in Little Outliner:

https://www.youtube.com/watch?v=_jrDW18R-Us

Ivan Sutherland's pioneering PhD thesis "Sketchpad" didn't show code or formulas or constraints on the screen all the time either, focusing on the graphical content itself that you were creating and editing and programming with direct manipulation, demonstration, and constraints, instead of just the code.

Ivan Sutherland Sketchpad Demo 1963:

https://www.youtube.com/watch?v=6orsmFndx_o

>This video is a TV show made about the software Ivan Sutherland developed in his 1963 thesis at MIT's Lincoln Labs, "Sketchpad, A Man-Machine Graphical Communication System", described as one of the most influential computer programs ever written. This work was seminal in Human-Computer Interaction, Graphics and Graphical User Interfaces (GUIs), Computer Aided Design (CAD), and contraint/object-oriented programming. While watching this video, remember that the TX-2 computer (built circa 1958) on which the software ran was built from discrete transistors (not integrated circuits -it was room-sized) and contained just 64K of 36-bit words (~272k bytes).

What many people don't realize about visual programming languages is that there are so many of them that look and behave extremely differently than the few recent and popular ones they might have actually seen and used, like Unreal Blueprints.

People have been inventing wildly diverse VPLs for a long time, and there is no one standard visual design (like graphs with boxes and arrows, interlocking blocks, text, images, etc) or execution model (like data flow, control flow, cellular automata, constraints) or interface style (like keyboard, mouse, dialog panels, notebook, direct manipulation, demonstration or example) that defines the genre.

Your narrow definition of VPL excludes not only spreadsheets but also Visual Programming by Example (VPBE), Programming by Demonstration (PBD), and Visual Constraint Programming (VCP), topics that Brad Myers and others have studied, researched, and written code and papers about for decades.

It also excludes groundbreaking influential work like Ivan Sutherland's 1963 "Sketchpad" PhD thesis that pioneered Visual Constraint Programming and many other advanced interaction techniques.

VPBE and PBD enable users to teach the computer new behaviors by demonstrating actions on the interface, rather than by writing code explicitly. This approach is inherently visual and interactive, focusing on the outcomes of actions to infer the underlying logic or procedures.

Brad Myers' 1987 PhD thesis "Creating User Interfaces by Demonstration" is one of his early and influential works in the field of PBD. It discusses the design, implementation, and evaluation of Peridot, a system that allows users to create user interfaces by demonstrating actions instead of writing code.

https://books.google.nl/books/about/Creating_User_Interfaces...

Peridot Full 1987:

https://www.youtube.com/watch?v=FsGx7G72V0Q

>Peridot was a system for creating User Interfaces that was created between 1985 - 1987. This video was previously published as: Brad A. Myers. Creating User Interfaces by Demonstration: The Peridot UIMS. Technical Video Program of the SIGCHI'88 Conference, Washington, D.C., May 15-19, 1988. and IFIP Interact '87 Conference on Human-Computer Interaction. Stuttgart, West Germany. Sept. 1-4, 1987. SIGGRAPH Video Review, Issue 59, no. 2.

"Demonstrational Interfaces: Sometimes You Need a Little Intelligence, Sometimes You Need a Lot" (1998): In this article, Myers explores the concept of demonstrational interfaces, which are a subset of intelligent user interfaces that allow users to demonstrate actions to achieve goals. The paper discusses the spectrum of intelligence required in such systems, from minimal to substantial, depending on the task complexity.

https://www.sciencedirect.com/science/article/abs/pii/B97815...

"Garnet: Comprehensive Support for Graphical, Highly Interactive User Interfaces" (1990, IEEE Computer): Myers and his colleagues introduced Garnet, a toolkit for creating graphical, interactive user interfaces. Garnet supports PBD in the context of UI development, making it easier for developers to create and manipulate UI elements.

https://www.cs.cmu.edu/afs/cs.cmu.edu/project/garnet/www/gar...

I worked with Brad on Garnet at CMU, wrote about it on HN, and wrote a comparison of Garnet and OpenLaszlo:

https://news.ycombinator.com/item?id=11232154

Constraints and Prototypes in Garnet and Laszlo:

https://web.archive.org/web/20070207232741/http://www.donhop...

"Constraints are like structured programming for variables":

https://news.ycombinator.com/item?id=11232154

"Programming by Example: Intelligence in Demonstrational Interfaces" (1992, Communications of the ACM): This paper discusses the role of intelligence in demonstrational interfaces, emphasizing how such systems can infer user intentions from examples to automate tasks and create programs.

https://dl.acm.org/doi/10.1145/330534.330545

"Past, Present, and Future of User Interface Software Tools" (2000, ACM Transactions on Computer-Human Interaction): Although not solely focused on PBD, this paper, co-authored with Scott E. Hudson and Randy Pausch, provides an extensive overview of user interface software tools, including those that incorporate principles of programming by example and demonstration.

https://dl.acm.org/doi/10.1145/344949.344959

Myers has contributed to several books either as an author or editor, covering topics related to user interface design, software development, and PBD. One example is "Watch What I Do: Programming by Demonstration," which Myers edited. This book is a comprehensive overview of the field of programming by demonstration, featuring chapters by various authors on different PBD systems and theories.

https://www.e-booksdirectory.com/details.php?ebook=3365

Ivan Sutherland developed "Sketchpad" as his PhD thesis at MIT in 1963, which is often considered one of the earliest examples of visual programming. Sketchpad was revolutionary for its time, introducing concepts that laid the groundwork for interactive computer graphics, graphical user interfaces (GUIs), computer-aided design (CAD) systems, and indeed, visual programming itself.

https://en.wikipedia.org/wiki/Sketchpad

Ivan Sutherland Sketchpad Demo 1963:

https://www.youtube.com/watch?v=6orsmFndx_o

>This video is a TV show made about the software Ivan Sutherland developed in his 1963 thesis at MIT's Lincoln Labs, "Sketchpad, A Man-Machine Graphical Communication System", described as one of the most influential computer programs ever written. This work was seminal in Human-Computer Interaction, Graphics and Graphical User Interfaces (GUIs), Computer Aided Design (CAD), and contraint/object-oriented programming. While watching this video, remember that the TX-2 computer (built circa 1958) on which the software ran was built from discrete transistors (not integrated circuits -it was room-sized) and contained just 64K of 36-bit words (~272k bytes).

Nicholas Jackiw's "The Geometer's Sketchpad" (GSP) is considered a Visual Programming Language (VPL) within the context of educational technology and mathematics due to its innovative approach to geometry, algebra, and calculus through direct manipulation and visualization. While not a VPL in the traditional sense of software development or general-purpose programming, GSP embodies key aspects of visual programming that make it a powerful tool for learning and exploration in mathematics.

https://en.wikipedia.org/wiki/The_Geometer%27s_Sketchpad

Macro Recorders (i.e. Emacs keyboard macros, Photoshop actions, etc): Many applications allow users to record a series of actions (like formatting text or organizing data) as macros. You demonstrate the desired actions, and it records your actions as executable steps. The "code" behind these macros is often generated automatically and can be edited textually, but the initial programming is done visually through demonstration.

Interactive Data Analysis Tools (like Tableau, Microsoft Power BI, etc): Some data analysis tools let users manipulate data sets visually (e.g., through drag-and-drop interfaces for selecting data ranges or specifying graph types), and then automatically generate the scripts or queries that represent these actions. This approach allows users to "program" data transformations and visualizations without writing code directly.

Graphical User Interface Builders (like XCode, etc): GUI builders, often found in integrated development environments (IDEs), allow developers to design interfaces by arranging components visually. Properties and event handlers can be assigned through demonstrations or interactions with the interface, such as by selecting elements and setting their characteristics through property windows. The underlying code for the GUI is generated by the tool, based on the visual design.

End-User Development Tools: Platforms designed to creating custom applications or automations through demonstration. For instance, tools like IFTTT (If This Then That) or Zapier allow users to create "applets" or "zaps" by choosing triggers and actions from a list of services and configuring them without seeing any traditional programming code. The logic is entirely defined through the visual assembly of components.

AgentSheets is a visual programming environment that allows users, including those with little to no programming experience, to create their own simulations, games, and interactive stories. It is particularly known for its use in educational settings to teach computational thinking and programming concepts.

Programming by Example in AgentSheets: The environment supports a PBE approach through its "Visual AgenTalk" programming language. Users can specify the behavior of agents (the active components in their simulations or games) by defining rules in a visual manner. These rules are often created by demonstrating actions or setting up conditions and outcomes using a graphical interface, which the system then translates into executable logic.

https://agentsheets.com/

https://edutechwiki.unige.ch/en/AgentSheets

David Ackley's "SPLAT" programming language for the Moveable Feast Machine, and Lu Wilson's "Sandpond" visual cellular automata programming language, let you define rules by example, which I recently wrote about on HN here:

https://news.ycombinator.com/item?id=39632735

I run one for a financial services firm and often get "excel couldnt merge changes, want to save a copy or discard". We tested this out, 2 users make editing different sheets on a single excel workbook hosted on sharepoint and excel can't figure out how to merge. If someone is on VPN and connection drops this also often occurs.

I'm not recommending any of this, but it can go as far as you want...

- understanding that formulas can return arrays, not just single elements (easier in more recent versions of Excel which have made this more consistent for every formula), so you can e.g. AVERAGE(IF(A1:A100>100,A1:A100,FALSE)) get the average of the values between A1:A100 which are greater than 100. the FALSE parameter can be omitted there but I left it in for clarity. Interestingly this means AVERAGEIF() is just syntactic sugar, so I prefer to avoid it. it makes it easier to, say, change to MEDIAN(IF(...)) later, since MEDIANIF() doesn't exist

- if you combine the first two bullets above, you'll enter the fifth dimension

- don't ever hardcode a value if you can refer to it somewhere else. want to use INDEX(MATCH()) and AVERAGE to, say, take some average value over some time period? put the start and end dates into their own separate cells with no formulas, and then refer to those cells in your formula. if you later need to change the time period, you won't have to modify all your formulas, just those values

- LET() is strange at first but super powerful. most people still don't use it

- Separate data from presentation. This point can't be stressed enough. I care about it so much I'm literally building an Excel competitor to enforce this. If possible, separate raw data, data transformation and data presentation.

- most people know you can name cell ranges and refer to them in your formulas. most people don't know you can also name formulas and refer to them elsewhere. your "average value over time" calc doesn't even need to be in a cell anywhere, it can just exist as a defined value in a named range. now named ranges are hard to see (only visible if you open the name manager), harder to debug (you basically get just a #VALUE error most of the time, forcing you to copy-and-paste the named range into a cell to debug it) and they get copied to other workbooks when you copy-and-paste across workbooks, which makes them super messy.... but for short formulas they can be pretty nifty

- LAMBDA() is even more recent than LET() and basically makes named ranges more useful. even fewer people use it

That's how I do it and it works great. I've gained a new appreciation for Excel.

After those 10, they break them down by category, and have one for Financial Functions, which is going to be useful for you. Similarly, the Logical, Math & Trig, and Stats functions, will all be useful for looking at a Finance firm's spreadsheets.

[1] https://support.microsoft.com/en-gb/office/excel-functions-b...

* Avoiding hardcoding numbers, making input cells a certain color, etc.

* Knowing the all powerful F4 key that alternates between A1, $A$1, $A1, and A$1 (and knowing what each of these mean)

* Inserting blank lines above and below a summed range and including those rows inside of the sum formula (prevents formula from breaking if you move rows around)

Other than that you can do a lot of productive things with a combination of index/match and dynamic named ranges via offset formula.

I find I learn best from (good) books because they actually explain things coherently, and you can leaf through them to discover features and things that look interesting.

Link from Reddit post: https://www.reddit.com/r/excel/comments/14zj5vz/you_suck_at_...

That sounds wild. Do you or your friend have anything to share about this?

https://www.youtube.com/watch?v=xubbVvKbUfY

https://www.youtube.com/watch?v=ICp2-EUKQAI

https://www.youtube.com/watch?v=UDGdPE_C9u8

The content itself is about demonstrating how an LLM/Neural net works using a spreadsheet and is a play on the title "Attention is All You Need". It has nothing to do with using a spreadsheet for most of your use cases.

Thanks! There's a truth to the name beyond just the play on the transformers paper. Definitely have thought about how many SaaS apps could be a spreadsheet and vice versa and often use them to create mini-apps (often via apps script).

I have seen that several times while I was a consultant. People run their stuff on spreadsheets. It’s a big mess but things get done . IT comes in and starts producing “professional” systems. Months of requirements gathering, then they deliver something. It’s not 100% right so people need to write tickets. IT may or may not make the changes. If they make a change it takes forever. People still need to do their job so they go back to spreadsheets.

* https://github.com/InkboxSoftware/excelCPU

* https://www.youtube.com/watch?v=5rg7xvTJ8SU

A twenty-four instruction assembly language is also provided.

https://web.archive.org/web/20230831003431/https://www.portu...

He actually quit the company to build it; I should find out what came of that.

https://www.deepexcel.net/

Interestingly it could fit within Powerpoint for the web's limits (my guess is that's intended for images).

I have considered a pure browser implementation https://github.com/ianand/spreadsheets-are-all-you-need/issu...

I wonder if it would work in https://rowzero.io/home ?

other than that, I agree with the other poster and the only issue I can think of is due to having a different number of digits after the decimal point causing some rounding error when comparing floats

Gsheets intuited that I wanted to do this multiple times and offered this formula:

> =RIGHT(A7,LEN(A7) - (FIND(CHAR(160),SUBSTITUTE(A7," ",CHAR(160),2))))

How is that related to anything?

Was it, at least, the correct formula for your need?

Yes it was correct.

It gave me 43h0m from "08 Jan 43h0m". Obviously over a column. I was able to adjust that to give me time durations.

Being a proper geek, my first inclination was to build a web app to keep track of that and so the people I am loaning cash to can also view their balance, but I realized that would involve maintaining state and login creds and a bunch of other variables I haven’t even considered, and maintaining this app would become a second, unpaid job.

Then I thought “I could just use a Google sheet and share it”, which is what I ended up doing. It’s easy to set permissions, I don’t have to worry about hosting, I can have it do any amount of arithmetic and light programming that I might need, as well as being automatic and reactive as I add information. It will be slower than something I would write in C obviously, but realistically for something involving budgeting the time savings will be on the order of milliseconds.

I love spreadsheets. They provide a gateway to programming for non-programmers, and they provide a low-effort means of playing with data.

Still, I meant everything I said about spreadsheets :)

The hyper-interactive nature of spreadsheets makes them kind of genuinely fun to tinker with. You can see results immediately, and you have enough logic (even in just the vanilla cells, not even counting JS or VBA) to implement a lot of algo stuff.

In this case, I don't think anything I'd do is going to be revolutionary, and I don't think I would have learned at that much, so Google Sheets was great.

In regards to "not paying on time", these are friends and family, so it's not like I'm going to go break their kneecaps or anything; if they're a bit short on the payment date we just push it back.

So it would absolutely be a second unpaid job, but I'll admit that I didn't specify why.