āœ‰ļø Not subscribed yet? Subscribe to the Newsletter

Future of Coding Weekly 2024/10 Week 1

2024-10-07 09:59

šŸŽ„ Boxer demo āœ Exploration of Drawing as Programming Language šŸ§¦ We have Dynamicland at home

Two Minute Week

šŸŽ„ k means clustering algorithm implemented in code flow canvas via Maikel van de Lisdonk

šŸ§µ conversation

Youtube Thumbnail

Here's a new video where I show the k-means clustering algorithm build in code flow canvas using some escape hatches. You can try it yourself on demo.codeflowcanvas.io (it's available in the examples)

šŸ’¬ client-side RAG and ticky UI holder for Observable by Tom Larkworthy

šŸ§µ conversation

I got excited about a client-side RAG thing working this week, but the most videoable thing I also got working was a sticky UI holder for Observable, which will be useful for hanging notebook extension upon.

šŸŽ„ sticky view

Our Work

šŸŽ„ The Coronavirus dashboard on Kendraio App via Daniel Harris

šŸ§µ conversation

Youtube Thumbnail

Hi everyone! I just made šŸ’¬ #introduce-yourself@2024-09-30 and promised a glimpse of our work. We (the Kendraio team) are currently experimenting with no-code, local-first and malleable-software isms.

We want to create a local environment where it is really easy for end-users and non-developers to build workflows and manage their own data, whilst also being able to plug into the services (apps and websites) that they currently use and build their own user-interfaces for those services. It's a big dream and we've started small.

A few years ago during the pandemic we built a dashboard for COVID-19 data. Our Flow plugged into various APIs and then visualised the received data on one page ā€“ so a good demonstration of one aspect of our dream. The dashboard still exists but shows historical data. We wrote an article about the dashboard which also has an accompanying video explaining how it works and how you can edit the Flow while it's running.

Enjoy! Look forward to any comments or questions. Cheers!

šŸ“ How we built mietencheck.de via Gregor

šŸ§µ conversation

Come for the rent price rant, stay for the i-cant-believe-its-no-code editor

šŸ“‘ SPLASH via Thomas van Binsbergen

šŸ§µ conversation

My students and I have worked on three papers (two prototypes) that will be presented at SPLASH at end of October

  • Christopher Esterhuyse -- Cooperative Specification via Composition Control (SLE2024)

  • This paper investigates control mechanisms in declarative languages that can be used by a programmer to have guarantees about the written program even when it is extended by other programmers. The work is motivated by distributed systems governed by policies in which the actors that provide the policies may have been competing interests. Concretely, think about (data sharing) contracts that are embedded in a federated cloud infrastructure.

  • Damian Frƶlich -- On the Soundness of Auto-completion Services for Dynamically Typed Languages (GPCE2024)

  • This paper investigates the use of "abstract interpretation" to give sound auto-complete suggestions for dynamic languages and demonstrates the technique on a subset of Python. Here "sound" means: if you select a given candidate, the inserted code will not contain variables that turns out to be undefined when the code runs.

  • Max Boksem -- Bridging Incremental Programming and Complex Software Development Environments (PAINT2024)

  • This paper demos a prototype that we built to investigate a modular graph structure for representing and running source code. The tool allows you to create different projections out of the code such as code structure, documentation view, and execution history. The tool supports incremental and exploratory programming and "nested graphs" (importing a graph as a node) for hierarchical views, although this is a more recent add-on.

Devlog Together

šŸ“ My notebook via Kartik Agaram

šŸ§µ conversation

My notebook now synchronizes the results of computation into named blanks in prose.

šŸŽ„ notebook eval

šŸ’¬ Kartik Agaram

šŸ§µ conversation

This debug UI has been surprisingly handy over the last few days. I'm able to visualize a parse tree even after it's been flattened, just using color transparency. All I'm doing is painting all the rects that contain the mouse cursor. Since the color is transparent, it doesn't matter what order they're in. (The larger rects actually come later; they're fall-backs if a more fine-grained rect isn't found.)

šŸŽ„ notebook debug

šŸ“ A plain-text notebook with tabsl via Kartik Agaram

šŸ§µ conversation

šŸŽ„ Notebook tabs

Reading Together

šŸ“ Eudability: A New Construct at the Intersection of End-User Development and Computational Literacy via Jasmine Otto

šŸ§µ conversation

through the visualization literacy working group, an extensive discussion of end-user development models & overlap with computational thinking. the two design axes alone are worth the price of admission::

  • component-based / rule-based / programming-by-demonstration
  • direct manipulation / conversational interface

Thinking Together

šŸŖµ pinokio via Andreas S

šŸ§µ conversation

Hey šŸ‘‹ I was recently searching again how "usable" "AI" became. So I stumbled on this tool: pinokio . Its all just JSON. Before just evalutating the tool I might describe the criteria I would be interested in. Broadly speaking I would like to have tool similar to what we see in this clip: youtube.com/watch?v=HGYFEI6uLy0

Consider The following more specific scenario:

I have a PKM Zettelkasten and I have some friends. Now my workflow is to write and then to publish. I want to provide for them a Voice assistant that can summarize contents based on various parameters: By time e.g. topics of last 3 months, last week. But I also want to provide overviews on specific topics as well as interesting interconnections.

Do you know of any tools that could help with creating such use cases?

šŸ’¬ Tomas Petricek

šŸ§µ conversation

This is a very random thought - but something that I've been occasionally wondering for some time now. If we have lambda calculus as a model of functional languages and Turing machines as a model of imperative languages, what would be a good model for programming systems that have "document" as the basic underlying structure (Subtext is an example of this) - i.e., you have some tree structure and the program evaluates by modifying this document - appending new things or rewriting evaluated bits. (Lambda calculus itself is basically a tree, but what if this also allows imperative document edits?)

Could this be something like a "Turing machine" that works on trees rather than tapes? There would be "current location" which can move in various ways around the tree and modify it. If your document has references (perhaps you can have ../../foo to refer to foo of a parent of a parent), the machine would have to somehow walk up the tree, remembering that it wants to copy a value back to the original location - and then walk over the tree back to put the value in place of the reference).

Is this something completely silly or something that lots of people have already done but under different names?

šŸ’¬ Rafi Khan

šŸ§µ conversation

Would anyone be interested in a browser based smalltalk environment that tries to simplify the task of building software?

Content

šŸŽ„ Boxer demo by Michael Ballantyne via Kartik Agaram

šŸ§µ conversation

Youtube Thumbnail

A rare and precious video walking us through Boxer.

šŸ§¦ A little wheel invention jam making a realtalk like environment. via Jimmy Miller

šŸ§µ conversation

A little wheel invention jam making a realtalk like environment. Super neat project. Love some of the implementation questions at the end as well.

šŸ§¦ Bret Victor's Worst Nightmare via Kartik Agaram

šŸ§µ conversation

Oh wow, so there were two Dynamicland homages in the jam! I was following @Ben Visness's project.

āœ Ī»-2D: An Exploration of Drawing as Programming Language, Featuring Ideas from Lambda Calculus ā€“ MIT Media Lab via Alex McLean

šŸ§µ conversation

An Exploration of Drawing as Programming Language, Featuring Ideas from Lambda Calculus

šŸ¦ Maxence Faldor (@maxencefaldor) on X via Mattia Fregola

šŸ§µ conversation

CAX: Cellular Automata Accelerated in JAX, a high-performance and flexible library designed to accelerate cellular automata research.

šŸ¦ Maxence Faldor (@maxencefaldor) on X: Interested in emergence, self-organization or morphogenesis?

Introducing CAX: Cellular Automata Accelerated in JAX, a high-performance and flexible library designed to accelerate cellular automata research. šŸ¦Ž

šŸ“„: CAX: Cellular Automata Accelerated in JAX šŸŒŸ: https://github.com/maxencefaldor/cax šŸ§µ1/12

Tweet Thumbnail

Music

šŸŽ¹ trane is a music playground via Greg Ash

šŸ§µ conversation

A few people were asking for a link at the London meetup earlier, so posting here:

lisp.trane.studio/?tutor

Code/docs here

šŸ¤–

šŸ’¬ William Taysom

šŸ§µ conversation

Fiddling with OpenAI o1-preview, I didn't know it cannot run Python to draw charts. Still it tried its darndest using ASCII art... Not bad except when you compare with the data it's trying to chart.

not-quite-right.png

raw-data.png

Present Company

šŸŽ„ Back to Basics with Technology - Future of Coding Meetup - London, 2nd Oct 2024 via Tak Tran

šŸ§µ conversation

Youtube Thumbnail

This is the talk I gave at the last Future of Coding London Meetup - Back to Basics with Technology. It goes through some of my recent explorations in electronics, crochet and light + a bunch of ideas Iā€™ve been mulling over: Back to Basics with Technology

Also in blog form: forestinthetree.com/blog/back-to-basics


šŸ‘ØšŸ½ā€šŸ’» By šŸ˜ @marianoguerra@hachyderm.io šŸ¦ @warianoguerra

šŸ’¬ Not a member yet? Check the Future of Coding Community

āœ‰ļø Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

šŸŽ™ļø Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2024/09 Week 5

2024-09-29 22:50

āœ Bloom: Optimization-Driven Interactive Diagramming šŸ”® The Future of Programming Systems šŸ’¬ FoC Bangalore Demos

Our Work

āœ Bloom: Optimization-Driven Interactive Diagramming via Josh Sunshine

šŸ§µ conversation

We just released Bloom, new way to create interactive diagrams and visual explanations. Creating interactive diagrams usually requires a programmer to write tedious event handling, collision detection, and tree update code. In Bloom, you simply tell the library what properties you want to maintain and the system does the hard work for you. Read this blog post to see cool example diagrams and learn more about Bloom.

šŸ’¬ Some demos shown at the FOC meetup in Bangalore by Nilesh Trivedi

šŸ§µ conversation

In this thread: Some demos shown at the FOC meetup in Bangalore yesterday (not everyone has joined this Slack yet):

Devlog Together

šŸ’¬ my parser via Kartik Agaram

šŸ§µ conversation

It took a couple of days but I've now completely rewritten my parser so it can serve both for display and computation duties. Displaying requires keeping track of spaces. Computation requires detecting invalid statements.

Now šŸ’¬ #devlog-together@2024-09-18 can perform computations in (indented) code lines.

Still missing: synchronization between code lines and prose lines. The screenshot for example shows me redundantly defining ice_kg = 2 to provide it to code lines. Also, heat_flux is computed in code, but not yet filled in the blank space in prose.

I'm continuing to accumulate design principles:

  • (generalizing from before) Everything is visible and easy to discover, whether it's the formula for a blank or the syntax to define a new blank or how to change colors. Any pattern you see on screen is easy to copy with the keyboard. (The one exception right now is the use of | characters in blanks and / in code. Both turn into horizontal lines.)
  • What you typed in is saved in the document -- except what you put into blanks in prose. Blanks are not saved, but can override default values defined in code.

notebook-eval2.png

šŸ”Œ demo.codeflowcanvas.io via Maikel van de Lisdonk

šŸ§µ conversation

Hi, this weekend I spend a lot of time tweaking and improving some stuff under the hood of Code Flow Canvas.. and I finally started building some unit/integration tests for the runtime flow engine as I want to reliably know when a flow is finished. I found some situations with certain node-types (the map and foreach node-types) that had some bugs in it that I didn't notice before. Also when the flow-engine was used in a none DOM environment there was a nasty bug somewhere deep in the system which caused nodes not to be reached... building tests for this really helped and save me some time debugging. All of this is important anyway but especially for the demo that I will give remotely at Live this year, because I don't want to surprise myself and anyone else šŸ˜Š...

In the attached screenshot you can see a new flow example that I made and hopefully make a video of next week: the K-Means clustering algorithm including visualisation of the clusters and centroids. You can already try it on demo.codeflowcanvas.io (it's in the examples).

image.png

Thinking Together

šŸ’¬ Declan

šŸ§µ conversation

I have lots of functions that map sets of inputs to values - depending on some rules (if branches). Now I want to enumerate all the rules/code paths; it will help me to analyse, optimise, explain, understand.

This can't be new, I guess it should be a thing that's feasible in any functional programming language. Maybe there is a name for this? Or a tool that does this?

I'm thinking about writing something, but it seems like a typechecker like tsc would have a lot of related logic, and if I can I'll experiment using some other friendly tool first. Any tips/references please shout, thanks!

šŸ’¬ Dany

šŸ§µ conversation

Should code completion preselect in the dropdown?

For example, if I write "object.l", this opens a dropdown with "length". Should the length be selected, so pressing "enter", inserts it directly or should I first need to press "down arrow"?

In visual studio, it is not preselect if I write a function, but does preselect for members. Is there some common approach?

šŸ”® The Future of Programming Systems - four thoughts via Jouke Waleson

šŸ§µ conversation

Not sure if this is the right place to post this and whether this is interesting to this group, but I gave a short presentation last week about the future of programming systems and curious what you think about it. I wrote it down in a blog post here: blog.waleson.com/2024/09/the-future-of-programming-systems-four.html

There are four thoughts that I think will shape the future:

  • Software development systems have a lot of vestigial parts (left-overs from the way it evolved)
  • Understanding is crucial to development, and with the right mediums we can understand the subject much faster
  • Most software platforms developed bottom-up, from the silicon, instead of focusing on the needs of the people
  • Software is truly different from other technologies in the freedom it gives us, so we can and should invent new abstractions that make things simpler than they are now

This isn't in the post, but I think that in the future we'll see:

  • Great integration between design tools, version control, IDEs, databases, monitoring & logging systems.
  • High-level concepts as first class systems in the programming systems. Simple examples are an email or phone number type as a database primitive, instead of strings.
  • Better reasoning / business logic rules so that IDEs can give feedback on "you are not allowed to store PII in this database".

This way all stakeholders can collaborate and the system can check correctness much better, and we require less discipline/in-depth knowledge from the team members.

I suspect most of these ideas have come by in this community already, but still curious what you think!

šŸ“ Functional Programming Is Letting Us Down via Paul Tarvydas

šŸ§µ conversation

šŸ’¬ Tomas Petricek

šŸ§µ conversation

I've been looking at programming by demonstration recently (somewhat inspired by Pygmalion). There are some nice recent examples of using PbD for things like data wrangling (clean up data, extraction, etc.) and I know some examples for visual things (bar chart) - but I was hoping to use PbD to create something like TODO list app - do people in this group know if there are any systems (recent or ancient) that do something like this?

I actually have a prototype where I can construct adding of new items to the list using PbD (you do a sequence of actions to create and add an item and then you can replay that), but other things are trickier - e.g. to count checked items or to remove items that are completed, there needs to be some way of parameterizing the actions (so that they can be applied to all items) and specifying pre-conditions (so that they only apply to certain items) - I'm really not quite sure how to best do those...

šŸ’¬ Kartik Agaram

šŸ§µ conversation

Today in non-convivial computing experiences: I found out a modern car can get into a state where it won't turn off. And can't be put into neutral (so it can't be towed).

Content

šŸ“ Conwayā€™s Game of Life implemented in PURE (no scummy Apps Script) Google Sheets via Mattia Fregola

šŸ§µ conversation

(also related my ā€“ admittedly less dynamic ā€“ Cellular Automata Google Sheet)

šŸ’¬ Robin Allison

šŸ§µ conversation

Hey future of coding folks,

I want to advertise the idea of non-abelian spreadsheets. The idea has slowly drifted into the center of my thinking this last year. I'm not sure if its a good idea or not. It kinda depends on how you build on it. So for now I just want to convey the general idea.

Picture in your mind a normal spreadsheet. In some sense it is 'abelian' (commutative) because from any cell going down and then right is the same as going right and then going down. If we make it non-abelian, so the order we go right and down matters, we get something like the picture attached below.

If you tilt your head slightly you may recognize it as the infinite binary tree. So an infinite binary tree is just the non-abelian version of the usual grid-based spreadsheet. The nodes of the tree are the cells. We can also think of finite binary trees as the analogue of tables.

A key feature of regular spreadsheets is the ability to write formulas with relative references. For instance in a regular spreadsheet you can use relative references so a formula always refers to the cell to the right of the given one, and in a tree you can write a formula that always refers to the cell you get by going down and to the right from the given cell.

Another key feature of spreadsheets is that you put stuff in cells! And we do that with trees all the time. For example if we write down the syntax tree for (a+b)*c what we are doing is putting each of the symbols into a cell of the tree.

We can push this analogy to account for all trees (in particular all syntax trees). This tree can't really be visualized because it branches infinitely at each node. It is much easier to describe algebraically. I'll use the term 'free monoid on a set X', which if you aren't in the know just means the set of strings made out of the elements of X regarded as distinct characters. The infinite binary tree, or more precisely the set of nodes of the infinite binary tree, can be described as the free monoid on a two element set {L, R}. e.g. RLL describes the node you get by going right, then left, and then left again. Now let X_n denote a set with n elements and X the disjoint union of the X_n for all n. It suffices to take the free monoid on X.

A reasonable question at this point is what is the interface for an infinitely branching tree? You would think it is even worse than an infinite dimensional grid, which is the abelian version. But if we are restricting ourselves to trees coming from symbolic expressions then for the most part we already have the interface. It is just the symbolic expressions we would have written down in the first place.

I'll leave it at that.

unnamed.png

šŸ„ Propagators via Mariano Guerra

šŸ§µ conversation

I created a wiki page about Propagators any resource you would add? Do you know of related ideas?

šŸ§‘ā€šŸŽØ Turnstyle via Mariano Guerra

šŸ§µ conversation

Turnstyle is a graphical esoteric programming language loosely inspired by Piet. Both encode programs as images, however, the similarities end at the syntax level.

Where Piet is really a stack machine in disguise, Turnstyle is an encoding of the (untyped) Lambda calculus. This allows for building more reusable images at a higher level of abstraction, while still keeping the specification small, making it relatively easy to develop new interpreters.

šŸ“ Turnstyle

Turnstyle is an graphical esoteric programming language based on lambda calculus.

Present Company

šŸ’¬ Jimmy Miller

šŸ§µ conversation

Anyone else here going to splash? I know Ivan Reese and Lu Wilson are presenting. Iā€™ll be attending. Just wanted to see if anyone else is going to


šŸ‘ØšŸ½ā€šŸ’» By šŸ˜ @marianoguerra@hachyderm.io šŸ¦ @warianoguerra

šŸ’¬ Not a member yet? Check the Future of Coding Community

āœ‰ļø Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

šŸŽ™ļø Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2024/09 Week 4

2024-09-23 19:02

šŸ¤– Bret Victor on AI šŸ“ Functional reactive programming šŸ“¢ Unconference by Ink & Switch

Two Minute Week

šŸŽ„ codeflowcanvas swagger endpoint generation via Maikel van de Lisdonk

šŸ§µ conversation

Youtube Thumbnail

In this video I show a new feature that I am working on in my codeflowcanvas project (which is a visual programming system and language): exporting a flow to typescript so that it can be used in other code-bases. In this example it's a nodejs-hono project for creating an api with a swagger/openapi documentation page

Our Work

šŸŽ„ Visualizing Vector Embeddings in 3D with transformers.js and t-SNE/UMAP via Mariano Guerra

šŸ§µ conversation

Youtube Thumbnail

I made a small tool: Visualizing Vector Embeddings in 3D with transformers.js, t-SNE/UMAP and echarts-gl

Get it here: github.com/marianoguerra/webvectors

šŸ’» Motif Designer via Natalie Freed

šŸ§µ conversation

Hello! I just listened to the AgentSheets episode and wanted to share that Iā€™m working on a PBE + block programming educational tool. Itā€™s a work in progress but the vision is of something like ā€œa macro recorder for Kid Pixā€ that lets you switch between drawing and code editing. motifdesigner.netlify.app Target audience is elementary school age kids, though itā€™s also meant to be fun for adults to tinker with.

Iā€™m excited that there seems to be a bit more traction (or at least interest?) around PBE again. I thought it was an interesting point in the paper/episode that it hasnā€™t necessarily gone out of fashion because it wasnā€™t a good idea, but because other solutions emerged to some of the problems it was trying to solve.

Devlog Together

šŸ“ Experiments With Text to Text Transpilation via Paul Tarvydas

šŸ§µ conversation

... Chipping away at articles regarding a bunch of experiments towards creating higher level syntax for programming languages. Thus far, I've managed to consolidate t2t (text-to-text transpilation) into a single .mjs file and to redocument it. Wrote an adjunct article about experimenting with "t2t" using a toy meta-programming language to generate code in existing languages. "T2T creates DSLs. T2T reduces the amount of work required to build a DSL. You should be able to create a new DSL in an afternoon. ..."

šŸ’¬ Kartik Agaram

šŸ§µ conversation

Very initial draft of a notebook UI.

There are 2 kinds of lines here:

  • Regular lines are prose, but you can also insert named blanks into them using the syntax [value|name] , which renders vertically across 2 lines. You can't nest blanks within blanks. These lines can wrap, but a single blank can't wrap across multiple lines on screen.
  • Indented lines (though the indentation is currently subtle) are code. They can render fractions using the syntax (a/b) as I showed before. (Not sure I'll keep this in the long term.) You can nest fractions within fractions. These lines don't support wrapping.

Planned:

  • synchronizing blanks with the same name
  • using code in indented lines to compute derived names without values inline.

Inspirations:

20240917-notebook.png

šŸ’¬ Kartik Agaram

šŸ§µ conversation

Today I've added some rudimentary styling syntax to my notebook.

It looks like I care about always making the styling very transparent, so it's possible in principle to guess what characters one needs to type to copy the look of something one sees on screen. So the style directives will never be hidden.

šŸŽ„ Style

šŸ’¬ Cross-link to a different thread. via Kartik Agaram

šŸ§µ conversation

There's a bug in my parser. Here's a debug UI showing it at a glance. The parse tree in the background is for the line the mouse pointer is hovering on.

One fun thing is the couple of lines in the middle there. I reached for a notebook to scribble some equations for myself, but then realized all I wanted was to be able to draw the fraction line horizontally -- and I'm sitting in a tool that can do that. Using the tool to debug the tool šŸ’„ (At least until I have no tools because I broke my tools using my tools. šŸ’¬ #of-ai@2024-09-22)

notebook-debug.png

Thinking Together

šŸ“ The Myopia of Professionalism via Jasmine Otto

šŸ§µ conversation

I am now blogging about design engineering in organizations that deal with lots of domain knowledge(s). This post covers metrics that don't do what your manager thinks they do, and why interdisciplinary work has trouble finding a good home.

šŸ’¬ Misha A

šŸ§µ conversation

What is "program"? essentially, conceptually.

šŸ¦ leslie (@lesliexin) on X via Christopher Shank

šŸ§µ conversation

I like this metaphor of translucent software both as a callback to the translucent hardware aesthetic of the 2000s, but also to progressively display the underlying mechanisms of software ~if~ you want to see it.

šŸ¦ leslie (@lesliexin) on X: Finally got around to building this :)

Try it at https://translucentweb.site/

Tweet Thumbnail

Content

šŸ“¢ Unconference hosted by Ink & Switch via Ivan Reese

šŸ§µ conversation

Tight zoom-in ā€” mid-September 2024 ā€” virtual roomful of online humanoid computer brains who maintain material co-presence in LA, or are translocating to SPLASH in October

There's going to be an unconference hosted by Ink & Switch on the 26th of October.

This has not been broadly announced yet. We're in the "invite the people who you really want to be there" phase. That means all of you!

Take a look at the list of attendees. Brilliant weirdos, the lot. You should come, you should come, you should come.

šŸ“ Functional reactive programming via Jasmine Otto

šŸ§µ conversation

A full-blown tutorial on DIY functional reactive programming, from one of the Spritely folks. Also collects relevant PL dissertations on dataflow, e.g. FrTime and propagators, as well as explorables like Holograph.

šŸ“ SwissGL tutorial: Reaction-Diffusion donut via Mattia Fregola

šŸ§µ conversation

šŸ•øļø 1992 mailing list post from Tim Berners-Lee via Ivan Reese

šŸ§µ conversation

A fascinating 1992 mailing list post from Tim Berners-Lee where he briefly outlines his desires for a programming language for the web ā€” basically, what JavaScript could have been.

The principles of hypertext are on full display:

You need something really powerful, but at the same time ubiquitous. Remember a facet of the web is universal readership.

Then there's the PL nerdery:

Ideally, the language should include object-oriented inheritance, a basically functional nature, and a clean syntax. It should be interpretable and compilable. At least one public domain. A pre-compiled standard binary form would be cool too.

My favourite bit, though, is the desire for the client/server to negotiate over the language of the executable document, just like they negotiate other details. There are some wild isomorphism implications here.

In reality, what we would be able to offer you real soon now with document format negotiation is the ability to return a document in some language for execution, with the option of being able to provide it in several languages, the language being a "data format" which can be negotiated between client and server at run-time. For, for example, one could provide it in viola script and/or in /bin/sh which would cover most ofthe unix world.

šŸ¤–

šŸ“ Stephen Fry on technology and AI via Nilesh Trivedi

šŸ§µ conversation

Stephen Fry on technology and AI:

Machines are capable of bias, hallucination, drift and overfitting on their own, but a greater and more urgent problem in my view is their use, abuse and misuse by the three Cs . They are Countries with their specific ambitions, paranoias, enmities and pride; Corporations with their unaccountable rapacity and of course Criminals . All of them united by one deadly sin: greed. Greed for power, for status, for money, for control.

šŸŽ„ ChatGPT o1 preview + mini Wrote My PhD Code in 1 Hour*ā€”What Took Me ~1 Year via Mattia Fregola

šŸ§µ conversation

Youtube Thumbnail

šŸ’» Test Driven Development with AI: Writing a Decompiler via Tom Larkworthy

šŸ§µ conversation

I got test-driven-development working with AI ( o1-preview ) and it is totally nuts. It can do complex stuff, I am making serious progress with a decompiler with it

Test Driven Development with AI: Writing a Decompiler. The key was feeding the test suite results back into context (plus o1-preview's ability to improve code without forgetting half the stuff in the middle)

šŸ“ Very AI-skeptical article via Konrad Hinsen

šŸ§µ conversation

I just read this very AI-skeptical article, that basically says that today's generative AI has no credible business model and is unlikely to improve significantly enough to get one. While I am aware of counter-arguments to the technical aspects, I wonder if there are more positive takes on the financial/business aspects, coming from anyone else than AI vendors.

šŸ¤– Bret Victor on AI via Kartik Agaram

šŸ§µ conversation

Present Company

šŸŽ™ļø A new bonus episode of the FoC podcast via Ivan Reese

šŸ§µ conversation

For our Patreon supporters, there's a new bonus episode of the FoC podcast where we tryā€¦ really, we do tryā€¦ to talk about the new Dynamicland archive website, and the cool stuff on it. But, it's just damned hard to take all of this new material without considering a bunch of bigger picture questions about society, and visions of the future, and what it means to be "open" about your work. So hard.


šŸ‘ØšŸ½ā€šŸ’» By šŸ˜ @marianoguerra@hachyderm.io šŸ¦ @warianoguerra

šŸ’¬ Not a member yet? Check the Future of Coding Community

āœ‰ļø Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

šŸŽ™ļø Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2024/09 Week 3

2024-09-15 23:17

šŸ“‘ Little Languages Reading Club šŸ› Debugging in the Multiverse šŸ’” DrawTalking: Building Interactive Worlds by Sketching and Speaking

Two Minute Week

šŸŽ„ warping text in webgl space via Leonard Pauli

šŸ§µ conversation

Youtube Thumbnail

Our Work

šŸ’» An editor for text that renders fractions vertically via Kartik Agaram

šŸ§µ conversation

A minimalist project for creating arbitrary policies for drawing text to screen while remembering where you put everything so you can respond to mouse and keyboard events.

šŸŽ„ Juice demo (vim++) via Zak Miller

šŸ§µ conversation

Youtube Thumbnail

Very early days (and not as innovative as a lot of the things I see on here), but I started working on a vscode extension that takes some ideas from semantic editing to build something sort of vimlike but that has things like functions, parameters, etc as first class ideas so you can e.g. press f to select the nearest function, press q to go to parameters, and then press a to append a new parameter at the end (which adds a comma and space, or newline and space, or whatever, and then drops you in insert mode) Here's a little video if you're interested

šŸ§® HowMuchIs13BillionEuros.com via Declan

šŸ§µ conversation

Hi all, I made a page to contextualize 13 billion euros (or 14): an amount owed to Ireland in an EU Apple tax case and all over the airwaves here this week. I use some pretty silly back-of-the-envelope type calculations (the same ones also repeated a lot here this week!).

These calculations aren't especially interesting, but I think I'll use this example to illustrate a close link between numbers: the type that we read and report about everyday, and their formulas/workings - because all numbers have these.

Here you can also change numbers in calculang (e.g. change that 13Bn to 14Bn) and related numbers on the page will flash with updates.

I was glad of this exercise to focus on something a little more relatable to a simple spreadsheet, but portable and structured in terms of calculations imo, unlike a spreadsheet.

And I needed to face a wee small bit about the pains of finding data, and even afterwards: "linking" to it šŸ¤’ (i did a lot of c&p hardcode :dotted_line_face:)

The page is: HowMuchIs13BillionEuros.com

šŸŽ„ Future of Coding Schrƶdinger's Wiki as a Gloodata Plugin via Mariano Guerra

šŸ§µ conversation

Youtube Thumbnail

My contribution to the wikijam: Schrƶdinger's Wiki

A wiki with all the articles in it, each page "collapses" into existence on the first observation/visit.

The generation process uses Slack messages, podcast transcripts and community-adjacent papers to produce articles grounded in FoC's ideas.

It also has hypermedia features to navigate and explore the references in the same application.

šŸ“Š graph.cubode.com via Rebeca Garcia

šŸ§µ conversation

Hey guys, we built, documented, and soft-launched graph.cubode.com using agentic AI technology.

Itā€™s a basic micro platform that auto-generates customisable graphs from csv your data files, it then renders an embeddable web component and weā€™ve used echarts, which weā€™re very happy with.

It took us one month to build it and another month to ship it, (highlighting a potential opportunity in AI deployment infrastructure). Weā€™re rolling out new features weekly like a filtering settings, improvements in the AI Engine or pulling data from Notion DBs directly, weā€™re gathering user feedback to refine the UX and functionalities if you use it and like it/dislike it let me know!

Or if anyone is interested in the Medium articles look for Cubode and theyā€™re all there with step by step guides on AI architecting.

šŸŽ„ Cubode Product Demo

Devlog Together

šŸ“ Peeking Behind the Curtain via Paul Tarvydas

šŸ§µ conversation

a one-liner reply to someone turned into something with more lines than 1 ...

My biggest interest is in thinking about programming instead of coding .

Make reprogrammable electronic machines do something using whatever means possible.

ATM, I'm using draw.io[1] to draw programs, then t2t to compile draw.io's XML (graphML[2]) to code (say Python), then run.

Articles on my desktop, awaiting attention (coded and running and in github, but need more expansive docs and/or people with more energy) ...

šŸ’¬ Kartik Agaram

šŸ§µ conversation

I've got a REPL loaded up with all of FoC archives.

Just Lua, not something powerful like Common Lisp or Smalltalk. Still quite nice.

Thinking Together

šŸ—­ My reaction to something mentioned in the latest FoC podcast via Paul Tarvydas

šŸ§µ conversation

FWIW, my reaction to something mentioned in the latest FoC podcast (futureofcoding.org/episodes/073):

Computer Science isnā€™t about programming . Computer Science is about mapping computational thinking into the digital domain and discovering problems in an ad-hoc manner, then fixing the problems to make the mapping work on reprogrammable electronic machines.

šŸ’¬ Jason Morris

šŸ§µ conversation

When I started my law firm, I thought everything I knew about a client matter needed to be in "the file". I wasted a lot of time moving things that were perfectly fine where they were. I realized that "the file" was a naive metaphor I took from law firms pre-cloud. That changed my outlook about data models. I don't want my digital model of things to mimic the real world artifacts involved, and spend a lot of time trying to explain to my colleagues that just because a person files a motion by delivering a real or digital pile of pages with real or digital ink on them doesn't mean that the document and the motion are the same thing. A motion doesn't have a page orientation, and a document isn't potentially vexatious. But when I argue that we should be modeling the domain, not only the artifacts, my colleagues ā€” who are all also former lawyers ā€” don't seem to disagree so much as act as though I'm speaking heavenly script. Does anyone have any tips for persuading people who haven't been converted to the wisdom of domain modeling that maybe our systems should deal with the things we care about, and not only the things we can download or touch?

šŸ“± Huawei's triple foldable display phone via Nilesh Trivedi

šŸ§µ conversation

Youtube Thumbnail

Could Huawei's triple foldable display phone combined with software like Samsung Dex liberate portable devices from being consumption-oriented devices? šŸ¤”

Apple has kept a strong hold on keeping ipadOS from threatening macOS. But the Android ecosystem does not have that limitation (see Waydroid or BlissOS or PostmarketOS for example)

Projecting in the future, we might even get briefcase size displays/machines that unfold into a full tabletop-style communal computing interface.

šŸ° The main ideas behind Hest are... via Ivan Reese

šŸ§µ conversation

Reposting ;)

Periodic self-reminder.

The main ideas behind Hest are:

  • Nobodyā€™s made a good computer code out of things moving through space.
  • Moving through space is also about moving through time. Rewind is table stakes.
  • If moving through space is meaningful, then space itself is part of that meaning. Position, distance, velocity ā€” they mean something.
  • You can do things with this meaningful space-time visual code that you simply can't do in a non-moving visual code.

šŸ¤” Are there languages that emphasize the single-datum <=> collection-of-data duality? by Beni Cherniavsky-Paskin

šŸ§µ conversation

Are there languages that emphasize the single-datum <=> collection-of-data duality? E.g. making loop-with- if <=> filter -on-the-whole look very similar?

But that's just a programming curiousity; I'm more interested if there are any mind bicycles that help one think about local vs. global rules?

Physics is rich with examples where seeing both perspectives is insightful:

  • local F = ma <=> conservation of potential energy independent of specific path (for certain forces)
  • Gauss's laws relating single-point "differential" <=> volume/surface "integral" formulations of Maxwell equations
  • Noether's theorem is certainly up there, relating shapes of laws with conserved stuff, but I'll admit over my head...

Example task: For a while now I've dreamed of making a model of weather that's simple enough for paper+pen+tokens, or generally something "board game-ish". Lies-to-children are fine, but would like it to demonstrate at least basic mechanics: (A) wind caused by hotter air rising and leaving a vacuum; (B) evaporation over sea => rain over land (C) "rain shadow" beyond a mountain (my country has this).

It's not easy to discretize continuous-quantity equations into something like a cellular automaton... I'm leaning towards representing conserved quantities like water with tokens you can move, rather than per-cell state.

And I don't want some huge "simulation"ā€”I'd love to find rules that can demonstrate these processes in few enough steps to follow by hand.

Hmm say I have air that wants to go up + right, and it holds just 1 water tokenā€”which way do I move it? Well I suppose I want a bit larger numbers so quantization won't matter that much... And I probably want alternating horizontal vs. vertical game phases (also dealing with 1D slice at a time can reduce previous-vs-next-state confusions).

Any advice for tools to help think about rules/mechanics and what can emerge from them, beyond "try and see what what happens"?

(But I guess I really should play with large "sand" style models, then try to scale down! try-and-see is more powerful than merely keeping in my head.)

Content

šŸ“‘ Little Languages - Reading Club via Mariano Guerra

šŸ§µ conversation

Little Languages - Reading Club a list of reading resources around programming languages organized by topic

šŸ’” DrawTalking: Building Interactive Worlds by Sketching and Speaking via Lu Wilson

šŸ§µ conversation

Don't know if this already got linked here but... very cool paper about creating interactive scenes by drawing and talking

šŸ› Debugging in the Multiverse via Nilesh Trivedi

šŸ§µ conversation

Antithesis simulates a purely deterministic universe. The reasons we do that are to find bugs faster, and to make them perfectly reproducible once found.

šŸ¤” Containers via Kartik Agaram

šŸ§µ conversation

This XKCD still hits with the force of revelation 5 years later.

šŸ§¦šŸŽ„ Hypercard in the World, May 2016 via Daniel Garcia

šŸ§µ conversation

Youtube Thumbnail

HyperCard in the world. A laser-powered live-programming environment for the real world.

šŸ“ a turnkey solution for making inline canvases as a Jupyter extension via Jasmine Otto

šŸ§µ conversation

There might be a turnkey solution for making inline canvases as a Jupyter extension. Good luck identifying logical objects, but there must be some advantages over drag-and-drop. I'd use this for my current prototype but that my target domain's existing DSL is not (yet) graphical. For any other paper tool, diagram, nonlinear algebraic notation, what have you, there is a lot of potential.


šŸ‘ØšŸ½ā€šŸ’» By šŸ˜ @marianoguerra@hachyderm.io šŸ¦ @warianoguerra

šŸ’¬ Not a member yet? Check the Future of Coding Community

āœ‰ļø Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

šŸŽ™ļø Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2024/09 Week 2

2024-09-09 09:59

šŸ“¢ PAINT & Causal Islands Berlin šŸ’» Decode: an augmented coding canvas šŸŽ„ Roboco-op: mimetic engineering

Two Minute Week

šŸ’¬ Marek Rogalski

šŸ§µ conversation

Working on performance improvements now. Getting some nice visual effects thanks to uninitialized memory.

Our Work

šŸ§‘ā€šŸ”¬ Account of the research project weā€™re doing at JetBrains by Pavel Mikhailovskii

šŸ§µ conversation

Hi everyone!

Iā€™d like to give an account of the research project weā€™re doing at JetBrains.

It is called Ludwig after Ludwig Wittgenstein and has an ambitious goal of re-engineering the foundations of the software development stack.

At the moment, we are still at a very early design and prototyping stage, but we believe that this project will let us create the next generation of development tools.

Here are the most important ideas weā€™re trying to materialize:

Liberation of code from the shackles of textual representation

Human-readable textual notations were a great innovation back in the 1950s. However, we have made great progress in the ways we store complex data structures since then, and the typical codebase sizes have also grown by a few orders of magnitude.

Code is essentially a graph with one tree-like perspective more important than others. An adequate way of storing such complex and evolving data as code would be to put it in a versioned graph / linked document database, supporting Git-like branching and merging. That would get rid of the need for continuous parsing, indexing, symbol resolution and typechecking that constitute the code editing workflow in modern IDEs. We would resolve symbols once, at the moment of typing and store their unique identifiers (not just names!) in an indexed by construction and preserving referential integrity database.

That would also make such intentions as Rename, Move, Find Usages or Go To Definition trivial to implement. Of course, structural representation of code will come hand-in-hand with structural (semantic) diff and merge.

This graph-like representation should allow for a fine-grained tracking of changes and dependencies and dramatically reduce feedback times in such scenarios as incremental compilation.

A minimalist approach towards programming language design

To prevent our language from becoming ā€œfat and weakā€ as John Backus has put it in his famous lecture, we want to pass our language through a series of aggressive optimization rounds or distillation passes.

This should result in something comparable with Smalltalkā€™s ā€œsyntax on a postcardā€. Actually, we believe that we could make it even more symmetric by eliminating the distinctions between methods, named and anonymous functions, operators and statements. (As you know, Smalltalk has different syntaxes and different behavior of return statements for methods and blocks and ā€œsurprisingā€ execution order rules for different kinds of messages).

The goal is to come up with a language that would be easy to learn and read and straightforward to reason about for all kinds of agents-be it humans, static analysis tools or AI.

In terms of notation, it will look like an indentation-based syntax for a tiny subset of Lisp, but without its macros or the zoo of ā€œspecial formsā€. Being freed from the limitations of plain text, weā€™re going to use semantic coloring to make the notation even more expressive and compact.

Obviously, our programming language, as any other, should be able to express computation logic and code structure; what is less common is that we also want it to be able to express data, configurations and knowledge, thus eliminating the need for additional DSLs. A YAML-like data notation emerges from our tiny language as naturally as JSON emerged from JavaScript. The only difference is that JSON was discovered by chance, and our language is consciously designed to be able to declaratively describe complex data structures.

Unification of Object-Oriented and Functional programming

As a part of our minimalist program, we are aiming to heal the great schism that divided programming into the object-oriented and the functional worlds.

We believe that the class-free approach in the form proposed by Douglas Crockford will let us make OOP an integral part of functional programming, thus converging the two into what could be called unified programming. This form of OOP will keep the best partsā€”encapsulation and polymorphism and get rid of the "considered harmful" implementation inheritance. There will be no need for classes, constructors, prototypes, visibility modifiers, this and new - just immutable structures and anonymous functions.

An IDE designed for focus and context awareness

We want to build an immersive Smalltalk-like environment with structural navigation, a smaller editing scope and richer and more dynamic context compared to the traditional file- and text-based IDEs. This seems well-aligned with both the minimalist design of the language and the non-textual storage format. The latter should allow us to store some additional information alongside the code. That will include all kinds of metadata, normally invisible to the users, but also some unusual forms of embedded content. Think of a documentation comment containing a video explaining the algorithm or a discussion between multiple developers linked to a certain place in the code.

Smart typing

We also have some ideas on how we could implement some smart typing techniques, combining the convenience of automatic type inference with the solidness and discipline of explicit type annotations.

The key idea is that the flexibility of the non-textual representation will eliminate the need for the user to choose between the two worlds. Manual annotations can be hidden to reduce visual distraction, automatically inferred types can be displayed and persisted in the code database, etc.

Designed to be AI-fitting

Finally, we want the whole thing to be future-proof and provide better support for AI-aided development compared to the traditional languages. The simplicity of the language as well as its fine granularity and its property of always having all the symbols resolved should allow for high-quality ā€œunderstandingā€ and retrieval-augmented generation of code compared to such languages as Python or Java.


As I said, at the moment weā€™re still at a very early stage. Many of our challenges are not technical, but about finding the way of how we could shape this set of ideas into a product vision. We are, of course, open to collaboration with like-minded people.

I will be happy to answer your questions and hear your feedback.

šŸŽ„ code::dive 2017 ā€“ Douglas Crockford ā€“ The better parts

code::dive 2017 ā€“ Douglas Crockford ā€“ The better parts

šŸ’¬ Jarno Montonen

šŸ§µ conversation

Added tabular data and document template import to my notebook demo so now it can be used to fill/generate documents from csv/spreadsheet rows. Would any of you find something like this useful? I know there are a bunch of document generators, but the ones I've seen seem kinda crappy. Happy to hear about experiences using any of the existing solutions and why they suck though šŸ˜†.

šŸŽ„ Document Generation

šŸ“ About - The Parallel Reality Computer via Duncan Cragg

šŸ§µ conversation

Hiya folks, now that many of you have been digging in to Dynamicland's website for a bit and are in the right frame of mind, I was hoping that you may have had your neurons tickled in just the right ways to be open to reading about a project with some similarities: mine! šŸ¤—

So I updated my About page, and I was hoping that it's now short and accessible enough to be just the info needed for you to "get" what my project is all about:

šŸ“ About - The Parallel Reality Computer

šŸ’¬ Kartik Agaram

šŸ§µ conversation

Still lots missing, but check this out.

Lol, look at how it renders hyperlinks. This isn't going to be useful without some sort of delimiter or fence around math.

fractions-bug.png

Thinking Together

šŸŖ¼ Physics of JellyCar: Soft Body Physics Explained via Christopher Shank

šŸ§µ conversation

Youtube Thumbnail

What are ways we can make computation more squishy with soft-body physics? Most visual notations are overwhelmingly rigid and structured!

Content

šŸ’» Decode via Ivan Reese

šŸ§µ conversation

Decode ā€” a new tldraw-based augmented coding canvas tool from @Francois Laberge

šŸ“ Situated Computations: Bridging Craft and Computation in the Trinidad and Tobago Carnival via Jasmine Otto

šŸ§µ conversation

a paper from an architectural journal that combines an ethnography with a sculptural grammar ('situated computations').

šŸ§¦ dynamicland.org via Alex McLean

šŸ§µ conversation

I hear dynamicland.org will update sometime today..

šŸ’” Donate to dynamicland via Ivan Reese

šŸ§µ conversation

Somewhat buried in the new DL webpage ā€” you can now directly donate to support their work. This is absolutely the sort of thing I'd back on Patreon, so I'm glad to see they offer those sorts of $n/month options.

šŸ“ The Canary via Kartik Agaram

šŸ§µ conversation

No coding here, but this is fantastic.

The Canary

And yet even now his father hovered in the background both as a rhyme and a presence. The careers of both men had been redirected by a simple question posed in a college class. Both spent their lives measuring the stress in stone. Both used scientific methods to answer questions that had seemed to everyone else beyond the reach of science. Both sought to understand what prevented roofs from collapsing. The fatherā€™s work had received a lot of public attention and the sonā€™s had not. But that was just an accident of what people cared about. A lot of people cared about Gothic cathedrals; fewer were concerned with whatever was happening to workers deep underground.

šŸ“¢ PAINT: Programming Abstractions and Interactive Notations, Tools, and Environments via Beni Cherniavsky-Paskin

šŸ§µ conversation

Looking at SPLASH '24 program, I knew LIVE workshop is always very relevant (this year majority of lectures involve folks here); but also found PAINT which sounds great too šŸ‘€

In the workshop on Programming Abstractions and Interactive Notations, Tools, and Environments (PAINT), we want to discuss programming environments that support users in working with and creating notations and abstractions that matter to them. We are interested in the relationship between people centric notations and general-purpose programming languages and environments. How do we reflect the various experiences, needs, and priorities of the many people involved in programming ā€” whether they call it that or not?

Areas of interest to PAINT include but are not limited to:

  • Design and implementation of program representations and their means of interaction for end-users of all ages
  • Design and implementation of visual programming environments
  • Block-based environments and their application
  • Projectional editors and their application
  • Languages and their environments with mixed notations
  • Meta tools or tool creation frameworks
  • Methods to support working with abstractions, such as example-based programming
  • Input and output devices for interacting with programming environments
  • Theories of the above

PAINT format is flipped, kinda critical review, and not recorded IIUC. But the past papers look interesting.

šŸ“ A note on the PERQ computer via Ivan Reese

šŸ§µ conversation

A fun little rollercoaster of computing history shared in this short blog post by Graydon Hoare, looking at the lesser known Xerox Alto descendant, the PERQ.

šŸ“¢ Causal Islands Berlin via Orion Reed

šŸ§µ conversation

The Causal Islands Berlin conference (organised by me, Boris Mann, and Jack Rusher) is happening next month (Oct 4 & 5). Would love to see some of you there. It'll be quite small (100-ish capacity) but loaded with great talks and conversations. We'll also be doing a more full-size conference in May next year. The vibes are "future of computing" and "spiritual successor to Strange Loop" with a more socio-political bent.

Also, there is a CfP up if you want to submit a presentation!

šŸ§‘ā€šŸ’» To Write Code: The Cultural Fabrication of Programming Notation and Practice via Joel Chan

šŸ§µ conversation

greetings! am thoroughly enjoying the latest podcast episode on agentsheets, and the discussion of ā€œis programming a Language(TM)ā€ and the history of how it came to be that programming was considered language in the sense of ā€œhas a formal grammarā€ reminded me of this paper by Ian Arawjo on the history of programming notation and its cultural referents (e.g., typewriters, and how it moved away from more ā€œvisualā€ forms and converged around ā€œprogramming as typing on a typewriterā€: To Write Code: The Cultural Fabrication of Programming Notation and Practice

i found the resulting frame of programming as translation work of ā€œmapping one culture to anotherā€ provocative too!

CleanShot 2024-09-07 at 14.41.31@2x.png

CleanShot 2024-09-07 at 14.43.59@2x.png

šŸ¤–

šŸ’¬ Nilesh Trivedi

šŸ§µ conversation

TIL:

image.png

image.png

šŸŽ„ Roboco-op explainer via Tom Larkworthy

šŸ§µ conversation

Youtube Thumbnail

I thought I had shared roboco-op here but it seems I had not. The idea is to mix code/runtime/chat context into a single materialised human editable representation to enable "mimetic engineering". Copy and pasting "skills" between notebooks and therefore engineering the AIs context to suit the task at hand, all while having a machine checked code based conversation (I demoed this at Berlin's GenAI meetup) withou context switches.


šŸ‘ØšŸ½ā€šŸ’» By šŸ˜ @marianoguerra@hachyderm.io šŸ¦ @warianoguerra

šŸ’¬ Not a member yet? Check the Future of Coding Community

āœ‰ļø Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

šŸŽ™ļø Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2024/09 Week 1

2024-09-02 10:19

šŸŽ™ļø FoC 73 ā€¢ Moving Beyond Syntax šŸ“¢ Onward! and LIVE Papers Announced šŸ§¦ Hypercard in the World

Two Minute Week

šŸ’¬ Karl Svartholm

šŸ§µ conversation

Trying to make Duplo more interesting... So far it is working (probably), seem to have encouraged my daughter to learn to stack two pieces together! šŸ˜ƒ

Actually the next step after a fanfare is probably (not the stars but) to have pieces make different sounds and/or beats depending on sensors (ex sensing colors, stacking, proximity or sound) ā€” a music machine. Perhaps more important: a programmer base plate; where you stack pieces & program them (from ex Arduino studio, for now). Inter-piece communication could also be interesting? Ideas?

šŸŽ„ Video 1

šŸŽ„ Video 2

IMG_20240826_084224.jpg

Our Work

šŸŽ™ļø Future of Coding 73 ā€¢ Moving Beyond Syntax: Lessons from 20 Years of Blocks Programming in AgentSheets by Alexander Repenning via Ivan Reese

šŸ§µ conversation

Finally, a title with appropriate length given the duration and depth of its episode. May it swiftly be surpassed.

Alexander Repenning created AgentSheets, an environment to help kids develop computational thinking skills. It wrapped an unusual computational model with an even more unusual user interface. The result was divisive. It inspired so many other projects, whilst being rejected at every turn and failing to catch on the way Scratch later did. So in 2017, Repenning published this obit of a paper, Moving Beyond Syntax: Lessons from 20 Years of Blocks Programming in AgentSheets, which covers his findings over the years as AgentSheets evolved and transformed, and gives perspective on block-based programming, programming-by-example, agents / rule / rewrite systems, automata, and more.

This is probably the most ā€œnormalā€ episode weā€™ve done in a while ā€” we stay close to the text and un-clam many a thought-tickling pearl. Iā€™m saying that sincerely now to throw you off our scent the next time we get totally lost in the weeds. I hear a clock ticking.

šŸ¤” Bloquecitos: the ultimate visual programming language via Mariano Guerra

šŸ§µ conversation

Inspired by the podcast episode above I created bloquecitos: the ultimate visual programming language

Try it here: marianoguerra.github.io/experiments/bloquecitos

šŸŽ„ Bloquecitos Demo

Devlog Together

šŸ’¬ Kartik Agaram

šŸ§µ conversation

Leveling up goals: a shower thought

Reading Together

šŸ“ BDI Agents: From Theory to Practice via Nilesh Trivedi

šŸ§µ conversation

LLMs are forcing me to think about non-deterministic yet rational "computation".

Agents are beyond what traditionally computation has been. When an agent starts performing a task, and the environment changes, they need to find the balance between too much rethinking (classical decision theory) and not enough rethinking (computation).

image.png

Thinking Together

šŸ’¬ Guyren Howe

šŸ§µ conversation

I just had a thought.

Is anyone aware of any work on a non-programmer-friendly UI for editing pattern matching? Semantically, Iā€™m looking for Datalog. So I guess a Datalog query UI, although I could imagine a pattern matching UI being developed outside of a use with Datalog.

šŸ’¬ Paul Tarvydas

šŸ§µ conversation

Iā€™m trying to figure out why you (Ivan Reese) think that using OhmJS to produce the wiki would create a dependency, while I (Paul Tarvydas) donā€™t think so. Hereā€™s a diagram of how I understand the situation...

tonedown.png

šŸ’¬ Nilesh Trivedi

šŸ§µ conversation

I've been thinking about how neurosymbolic AI might be achieved. The first problem is that of memory/knowledge. Triple stores are often recommended. But I am failing to see how triples are THE definitive choice for knowledge representation.

The classic example would be: How to store the fact "Bob's age is 23yrs". This maps to the Entity-Attribute-Value or Subject-Predicate-Object pattern and the triple (Bob, age, 23yrs) works.

But on one hand, even a 2-store can be used:

(Bob, Bob's age)

(Bob's age, 23yrs)

This has more layers of indirections, yes. But the primitives become simpler.

On the other hand, if the fact was "Bob bought this camera in Singapore for 100$", the same layers of indirections show up in triple stores as well.

Arbitrary knowledge seems multidimensional (time, place, context etc etc). Is there a reason to believe that triple stores achieve the best tradeoff between simplicity and expressivity?

šŸ“ 0048: zest progress, zest ordering, wasm alignment, umbra papers, future of fast code, new internet, books, other stuff via Jamie Brandon

šŸ§µ conversation

Does anyone have thoughts about equality vs ordering in maps/sets?

I have some pondering here - scattered-thoughts.net/log/0048/#zest-ordering but the decision tree at the end is the main thing:

  • Order isn't observable at all.
  • Iteration order is either non-deterministic or expensive.
  • Determism can be manually recovered by storing both a map and a list of keys, but at the cost of storing two copies of each key.
  • Order is observable.
  • Order doesn't affect equality.

  • Equality is not extensional ie a == b does not imply that f(a) == f(b) .

  • If [a: 0, b: 1] == [b: 1, a: 0] then we must have struct[a: i64, b: i64] == struct[b: i64, a: i64] , but we still have to remember that the field order is different, which implies that type equality can't rely on interning and pointer comparison.

  • Order affects equality.

  • Sets become surprising / less useful.

  • If I want to add query planning, I can't promise that f(db) == optimize-query(f)(db) .

Content

šŸ’” SPLASH 2024 - Onward! Essays - SPLASH 2024 via Konrad Hinsen

šŸ§µ conversation

The accepted contributions to Onward! Essays and Onward! papers have been announced. Many of the titles/abstracts sound very relevant for our community. And three essays have authors from FoC.

šŸŽ„ Capt. Grace Hopper on Future Possibilities: Data, Hardware, Software, and People (Part One, 1982) via Paul Tarvydas

šŸ§µ conversation

Youtube Thumbnail

Capt. Grace Hopper on Future Possibilities: Data, Hardware, Software, and People, 1982

  • Part One * youtube.com/watch?v=si9iqF5uTFk&t=1s

  • 20:58 - Weā€™ve Always Done It This Way *

  • 47:10 - Systems Of Computers, Not Bigger Computers *

  • 48:00 - Get Out Of The Plane Of Paper *

  • Part Two * youtube.com/watch?v=AW7ZHpKuqZg

  • 0:00 - Security *

  • 8:42 - Bloatware *

  • 9:57 - 2FA *

  • 12:12 - Specialized Machines Are Faster Than General Purpose Machines *

  • 12:59 -We Have To Overcome The Concept Of Only One Computer *

  • 14:58 - Dependency Analysis *

  • 18:53 - Use independent modules *

  • 22:15 - Advocate the use of standard high level languages *

  • 27:19 - Buying Computer Time *

  • 34:49 - Management vs. Leadership *

my thoughts on the above issues

šŸ§¦šŸŽ„ Hypercard in the World, May 2016 via Lu Wilson

šŸ§µ conversation

Youtube Thumbnail

Just in case you missed it

šŸŽ„ Subtext 1 via Kartik Agaram

šŸ§µ conversation

Vimeo Thumbnail

I had no idea Jonathan Edwards's landmark Subtext is almost 20 years old.

Subtext 1 (2005) is still hugely compelling. I hadn't watched this until today. If you're like me, you're in for a treat.

This work predates Bret Victor's "Inventing on Principle" by 7 years!

šŸ“‘ Workshop on Live Programming (LIVE) via Maikel van de Lisdonk

šŸ§µ conversation

The accepted list of papers for liveprog can be seen here liveprog.org and I notice that FoC is very well represented by quite some folks from this community, very nice! šŸ˜Ž

šŸ¤–

šŸ’¬ Nilesh Trivedi

šŸ§µ conversation

The holy grail of AI. Any thoughts on how this kind of integration can be achieved?

image.png

Present Company

šŸ”  Departure Mono via Christopher Shank

šŸ§µ conversation

DEPARTURE MONO IS A MONOSPACED PIXEL FONT WITH A LO-FI TECHNICAL VIBE

šŸŽ„ Virtual Meetup 4 ā€¢ August 28, 2024 via Ivan Reese

šŸ§µ conversation

Youtube Thumbnail

Here's the recording of the Future of Coding Virtual Meetup 4. We saw a textual projectional editor from @Jarno Montonen, an Observable-based exploration of visualizations from Tom Larkworthy, and I shared an update on the FoC Wiki.

Next month, rather than demos, we're going to host a little event where we all get together on a call and write wiki articles. Should be fun, likely chaotic. See you there!


šŸ‘ØšŸ½ā€šŸ’» By šŸ˜ @marianoguerra@hachyderm.io šŸ¦ @warianoguerra

šŸ’¬ Not a member yet? Check the Future of Coding Community

āœ‰ļø Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

šŸŽ™ļø Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2024/08 Week 4

2024-08-25 23:01

šŸ§® Scrapsheets demo šŸŽ„ Why Star Trek's Graphic Design Makes Sense šŸ”Œ Visual Neural Networks

Two Minute Week

šŸ”ŒšŸŽ„ Neural network training using mnist dataset in code-flow-canvas via Maikel van de Lisdonk

šŸ§µ conversation

Youtube Thumbnail

After lots of reading (books and other people's code), watching video's, thinking, asking chatgpt for help (it needed help itself), experimenting and frustration, I finally managed to get a neural network working including the training using backward propagation, in my visual programming system!! You can see a small video where I demo it here

The results are far from perfect and neither is the visual flow itself. Currently I only used a subset of mnist to train (9000 images) and on every training iteration the weights are updated per training image. Also the network can for sure be improvement by using a different layer setup and configuration parameters (different learning rate and activation / cost functions). From a visual programming perspective there are also lots of things to improve: currently a lot of the needed functionality is inside the nodes instead of being visible in the flow. So the neural and training nodes are black boxes as well as the node that loads the mnist dataset and handles some of the logic in the training proces. I want to change this in the near future though. You currently can't even see the resulting weights and biases.

Hopefully it is clear from the neural node types how the neural network is structured: it shows the number of nodes in the layer and an icon illustrating whether a node represents an input, hidden or output layer.

In the video I show a slow and fast run of the training proces: by putting the speed slider to the right you can run the flow without animations otherwise it takes too long.

There's also a custom node type that can be used to draw a digit manually and provide the digit which the drawing represents for purpose of calculating the error cost/loss.

Anyway, for now I am happy with the result. More to follow in the future :-)

šŸ’¬ Marek Rogalski

šŸ§µ conversation

They may be totally invisible in the video but objects in Automat now drop shadows! They're drawn using fairly sophisticated procedures that were developed a copule of years ago for Google's Material Design system. Each object actually drops two different shadows - one coming from environmental light (a.k.a. ambient occlusion) and one from directional light (which is modelled as a disk with the same width as window and is positioned in 3d space roughly in front of the title bar). The cool thing about those shadows is that they're not using either shadow maps nor gaussian blurs (except concave shapes). The library takes some shape (vector contour of the object dropping shadow) + parameters of the light and computes a physically based analytical shadow mesh that is then drawn in the background. This manages to render fairly realistic shadows even while elevation of objects is being dynamically changed.

šŸŽ„ Demo

Our Work

šŸ“ Call Return Spaghetti by Paul Tarvydas

šŸ§µ conversation

In the essay referenced below, I examine why a diagram of a Call/Return system makes less sense than a diagram of a concurrent system.

Call/Return operates in a LIFO - last-in first-out, stack-like - manner.

Adopting an alternate perspective - FIFO, first-in first-out, queue-like manner - allows us to represent diagrams more easily.

CPU chips implement CALL and RETURN instructions as single opcodes, but, they do not implement queue behaviour as single opcodes.

Most popular languages are generally function-based, e.g. C, Haskell, Python, Javascript, Smalltalk, etc. Such function-based languages tend to adopt a LIFO (callstack) perspective and tend to use CALL and RETURN opcodes to fake out the function-based paradigm.

Such languages allow programmers to implement FIFO queues, but, such languages encourage the use of LIFO stacks. This seemingly small difference subtly affects designs with function-based - stack-based - thinking. This difference ultimately encourages single-threaded design while making multi-threaded design more difficult to imagine and to implement, as witnessed by the fact that most languages relegate multi-threading to hefty code libraries, while treating functions as basic building blocks.

This subtle encouragement towards function-based thinking has led to the general impression that Visual Programming Languages (VPLs), node-and-wire Diagrammatic Programming Languages (DPLs), Actors, etc., are ineffective programming tools.

I argue that VPLs, DPLs, Actors, etc. are effective programming tools, but that their use is are ultimately discouraged by the over-use of the function-based paradigm.

Further

šŸ’» Tensort via Kyle Beechly

šŸ§µ conversation

I just published Tensort, a family of sorting algorithms (slash research paper?) inspired by Ivan's remark near the end of Beyond Efficiency by Dave Ackley about Robustsort not existing yet. I'd love to hear what y'all think! šŸ’™

šŸ“¼ Bootstrapping OOP Part 3: Who Parses the Parser? via Mariano Guerra

šŸ§µ conversation

How do we feed the prelude if there's no parser (yet)?

šŸ’” If code is data then a data serialization format is a binary representation of a program

Devlog Together

šŸ’¬ Kartik Agaram

šŸ§µ conversation

Getting ready for Slack apocalypse.

motd.png

šŸ”ŒšŸŽ„ Improved neural network layer node visualization in code flow canvas. via Maikel van de Lisdonk

šŸ§µ conversation

Youtube Thumbnail

I've made some visualization improvements for the neural network layer nodes in my visual programming system "code flow canvas". Nodes can now have meta information to show internal data which is stored on the node level that is not shown on the node itself. For the neural network nodes this are the weights and biases.

Also the structure of the neural network itself can be viewed in a scalable way instead of just the nodes on the canvas itself. And with scalable I mean not showing all the nodes, but only a max of 10 per layer and add smaller dots in between to illustrate that there are more nodes then just the max 10 that are shown per layer. The number of dots are different depending on the total node count to make it clear that layers differ in total node count.

You can see it here or try it yourself at demo.codeflowcanvas.io and select the neural network mnist training & testing example.

Thinking Together

šŸ’¬ Yuriy Zymlex

šŸ§µ conversation

I have a few questions/topics about which I would like to get your opinion. Since I'm interested in the underlying logic of this things, this may look banal.

If the essence of every programming language is the construction of logic , have there ever been any attempts to bring that process __ into minimal separate entity for purpose of wider use than just programming?

By purposes, I mean the creation of:

  • Text instructions - as you can see them in Jira, Org-Mode, Markdown (or detailed program's log)
  • Graphical - MindMap or here it is good to remember "data flow diagrams" from informatics, but it can be expanded to any other kind
  • Actually programming itself, but as building any "pseudo" code (including graphical) for convenient use with a theoretical possibility of converting "pseudo" code back to logic
  • ... (other variants)

Content

šŸ§®šŸŽ„ scrapsheets splash demo via Kartik Agaram

šŸ§µ conversation

Youtube Thumbnail

Demo of a spreadsheet-like tool. To be presented at SPLASH? By @Taylor Troesh.

šŸŽ„ Why Star Trek's Graphic Design Makes Sense via Stefan Lesser

šŸ§µ conversation

Youtube Thumbnail

YouTube served this older video to me, but I couldnā€™t help noticing a few things in relation to (the future of) coding:

  • All the models and (fake screens) etc. are now considered art, but they werenā€™t created as art. They were functional props on a movie/TV show set put together under tight timelines. How often do we put together functional code under tight deadlines? And how often is what we do regarded as art later? Almost never, I reckon.
  • His expertise: When he talks about smoked acrylic and how almost everybody doesnā€™t listen to him because ā€œYouā€™re losing light", even though he clearly knows exactly what heā€™s talking about, that reminds me of about a million conversations about how some clearly less experienced engineer tells an experienced veteran why their code isnā€™t good.
  • Oh, the pragmatism! The ship models? Hacked together from repurposing strange parts they had lying around. The details? Just enough to make it look great. The blinking buttons interface? Just a few lightbulbs behind the buttons that were supposed to blink. If that doesnā€™t remind you of software development, youā€™re not doing it right. Or you are, and thatā€™s part of the problem. šŸ˜‰
  • I know, thereā€™s some physicality to all the examples in the video, but the LCARS interface points to the possibility of designing something in software only that can transcend its functional framing and become more than just a prop. We have a few examples of that in software (ā€œYou had me at scrollingā€), but not nearly as much as we should have, I think.

Where are the videos like this that celebrate achievements in software design?

šŸ“ The Competing Predictions of Edsger Dijkstra and Douglas Engelbart via Kartik Agaram

šŸ§µ conversation

He who would do good to another must do it in minute particulars General Good is the plea of the scoundrel, hypocrite and flatterer For Art and Science cannot exist but in minutely organised particulars -- William Blake


šŸ‘ØšŸ½ā€šŸ’» By šŸ˜ @marianoguerra@hachyderm.io šŸ¦ @warianoguerra

šŸ’¬ Not a member yet? Check the Future of Coding Community

āœ‰ļø Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

šŸŽ™ļø Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2024/08 Week 3

2024-08-18 23:38

šŸŽ„ A structured, type safe and web native shell šŸø Arroost: Unblocking creation with friends šŸ”Œ Nodes & wires experiments

Two Minute Week

šŸŽ„ Draw a Triangle to a Window via Dany

šŸ§µ conversation

Youtube Thumbnail

Hello Triangle!

Our Work

šŸŽ„ A structured, type safe and web native shell. via Peter Saxton

šŸ§µ conversation

Vimeo Thumbnail

This video is a break from my normal log. This time I assume no previous knowledge and try to show what I thing a structured, type-safe and web-native shell should look like.

šŸŖœ Bootstrap post-collapse OOP technology with Wasm GC (Part 2) via Mariano Guerra

šŸ§µ conversation

šŸŖœ Bootstrap post-collapse OOP technology with Wasm GC (Part 2)

A raw WebAssembly (Text Format) implementation that bootstraps a compact object-oriented language in itself

~1500 lines of WAST, 5.8KB compiled to Wasm

šŸø Arroost: Unblocking creation with friends via Lu Wilson

šŸ§µ conversation

My submission to LIVE just got accepted. Here it is!

Please read and share and let me know what you think

Devlog Together

šŸ’¬ Ivan Reese

šŸ§µ conversation

Not an exhaustive test, but the gemtext superset / markdown subset is coming along. The parser is really simple. I need to style blockquotes and code blocks (likeā€¦ at all), and improve the styling on other elements. Also need to document this subset. But hey, getting closer.

Screenshot 2024-08-17 at 9.05.00ā€ÆPM.png

Screenshot 2024-08-17 at 9.07.45ā€ÆPM.png

šŸ—ŗļø the FoC starmap via Kartik Agaram

šŸ§µ conversation

Quick aside on "the making of" šŸ’¬ #thinking-together@2024-08-18. I've been reading Christopher Alexander's "The Nature of Order". I'm 250 pages (so 1/8th of the way) in, but I tried to make each node (problem statement) a "center" as CA defines it.

Initially I wanted distances to be meaningful but I couldn't see a way to make it work, so they're mostly meaningless (except for a couple of nodes with very few edges). Instead I ended up focusing on angles. I tried to make every edge unambiguously go to a specific node, and this had the effect of improving use of all 360 degrees around every node.

I started out putting myself in the center, but eventually realized it was better to start with people who had the most 1s and 2s (for the most part the only edges shown in these graphs).

FoC-starmap3-1.png

šŸ§µ read more...

Thinking Together

šŸ”Œ Writing software without a programming language via Paul Tarvydas

šŸ§µ conversation

Youtube Thumbnail

Iā€™ve been pointed at the Kronark YouTube channel which is only a few days old and purports to show how to build software using nodes.

Several things jump out at me: (1) nodes do NOT need to return a value (unlike functions, which must always return something ; does the need to return something lead to bloat???) (2) undefined behaviour is allowed (does over-defining of ALL behaviour lead to bloat???) (3) encapsulation and abstraction - 0D defines Container components which encapsulate and elide layers, 0D does this encapsulation at runtime ; Kronark compiles out encapsulation at compile time (AOT). I feel uneasy about this, when taken to the extreme. Maybe 0D should be described asā€œstructured concurrencyā€ (???) Whereas Kronark is just more-of-the-same linear composition (???) that works in a feed-forward, single-threaded manner. It will be interesting to see examples of concurrency and feedback in Kronark. (FTR, ā€œfeedbackā€ is not the same as ā€œrecursionā€).

šŸ—« Final-ish state of problem statements and reactions by Kartik Agaram

šŸ§µ conversation

Also, a final-ish personal visualization of the "star map of FoC". All the caveats and disclaimers šŸ’¬ #thinking-together@2024-08-04 continue to apply.

I'll post some even more personal comments and critiques of people's responses and the whole process in comments. I hope it provokes comments and reflection from others.

I'm looking forward to putting this up on the FoC wiki in some form.

šŸ—’ļø problems.html

FoC-starmap4-4.png

Content

šŸ¤– The AI Scientist: Towards Fully Automated Open-Ended Scientific Discovery via Mattia Fregola

šŸ§µ conversation

Curious to see how this Fully Automated Open-Ended Scientific Discovery thing unfolds

šŸ”ŒšŸ§® They turned MATH into a factory game... via Jason Morris

šŸ§µ conversation

Youtube Thumbnail

Saw *Beltmatic" and thought of Hest. šŸ˜…

šŸ”ŒšŸ¦ @KennedyRichard@fosstodon.org (@KennedyRichard) via Mattia Fregola

šŸ§µ conversation

Spaghetti-code polemics aside ā€“ how cute!

šŸ¦ šŸ¦£ @KennedyRichard@fosstodon.org (@KennedyRichard) on X: @KenneyNL No guys, hear me out, we might be onto something here! What about tracking eyes that become happy when the connection is reached out? (also in Nodezator's dev branch)

Tweet Thumbnail

šŸ¤–

šŸ“ The Turing Test and our shifting conceptions of intelligence via Mattia Fregola

šŸ§µ conversation

Good short article by Melanie Mitchell


šŸ‘ØšŸ½ā€šŸ’» By šŸ˜ @marianoguerra@hachyderm.io šŸ¦ @warianoguerra

šŸ’¬ Not a member yet? Check the Future of Coding Community

āœ‰ļø Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

šŸŽ™ļø Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2024/08 Week 2

2024-08-11 23:43

šŸ“” Userspace notebook editor ā›ļø Bootstrap post-collapse OOP technology šŸ”Œ cables.gl is now open source

Two Minute Week

šŸ’¬ Marek Rogalski

šŸ§µ conversation

This week I've implemented serialization format for machines built in Automat. Simple JSON file (pretty-printed) stored next to the executable. Turns out its quite handy during interactive development. And also opens the way for regression testing. Restoring the window state was (surprisingly) the hardest challenge (due to DPI and monitors) and I didn't manage to correctly persist it. Both on Linux and Windows, the window managers just don't want to share some of the window properties... (especially around window tiling)

šŸŽ„ Demo

šŸ“” observablehq.com/@tomlarkworthy/userspace-editor via Tom Larkworthy

šŸ§µ conversation

What would it take to make an open source front end to the Observable Runtime? One where you have control over the runtime and layout and are free from iframe sandbox restrictions?

šŸŽ„ open-notebook

Our Work

ā›ļø Bootstrap post-collapse OOP technology (Part 1) via Mariano Guerra

šŸ§µ conversation

How do we preserve the ability to program OOP through civilizational collapse?

2024-08-09_12-25.png

2024-08-09_12-26.png

Devlog Together

šŸ’¬ Ivan Reese

šŸ§µ conversation

Got the visual design of the wiki mostly fleshed out. Fluid layout, one breakpoint that moves elements around for smaller screens, light and dark modes, nice keyboard nav, etc etc. Thoroughly documented too, since I figure some folks might want to peek at the css but aren't up on all the new weird stuff you can do.

Also, I'll be eating my hat now: everyone who scolded me for attempting to parse a markdown-like syntax with Regex, well, yeah, it kinda stinks. Not sure what to do about this, given the values I'd like to impart in this project. Since it's not a blocker on writing pages, I think I'll ship it half-finished and we can talk about it. This feels like a great area to draw on the wisdom of the crowd.

Markdown or not, we'll still need a build script, I reckon, unless we want to ~require~ that anyone adding a new page also add their page to any relevant indexes ā€” since, I reckon, we'll need some indexes just to get through the early phase where the wiki will be sparsely interconnected. To start, I'm thinking one index of broad categories (or maybe tags, dunno), and then another that's just a list of all pages. But if anyone has strong feelings about the right way to do this, I'm at least 75% ears.

Thinking Together

šŸ“ How I program in 2024 via Andreas S

šŸ§µ conversation

Kartik Agaram is that your blog?

Content

šŸ”Œ cables.gl via Ivan Reese

šŸ§µ conversation

The cables.gl visual programming language for making cool WebGL shaders was just open-sourced.

šŸ’¬ Beni Cherniavsky-Paskin

šŸ§µ conversation

  • Just found Mr. 4th Programming Conversations podcast which mentions multiple FoC topics šŸ°. Visual programming, Bush & Englebart...
  • Developer Voices podcast is maybe less 1:1 match but interviews many developers building new/experimental/visionary languages.

šŸ¤–

šŸ’¬ Mark Dewing

šŸ§µ conversation

We now have two examples of systems that can turn text descriptions into code - humans and LLMs. And we don't understand how either of them works.

šŸ“ No apps no masters via Kartik Agaram

šŸ§µ conversation

Present Company

šŸ’¬ Dany

šŸ§µ conversation

So I have this c/c++ codebase, around 116,000 lines of code. A full release compilation takes 6:25 minutes. Not too bad to work on.

If I break this down, a single line of c/c++ code takes 0.0033s (3.3 miliseconds). For comparison, a game that runs at 60 fps, draws a new frame in under 16 miliseconds. So while a game simulates and renders a frame, a c/c++ compiler compiles 5 lines of code. That is usually not even a single function.

My cpu avarages at around 10 instructions per clock cycle. At 3.6Ghz it can do 3.6 * 10 * 1,000,000,000 instructions on each core, per second. That's 36,000,000 per milisecond, on 8 cores.. but let's add some cache misses, any instructions can either go full speed 1x or go to main memory around 200x slower.

We are looking at around 5 million instructions per milisecond.

If we print out (9pt font) all instructions executed to compile a single line of c/c++ code, we'd end up with over 6 kilometer long paper.


šŸ‘ØšŸ½ā€šŸ’» By šŸ˜ @marianoguerra@hachyderm.io šŸ¦ @warianoguerra

šŸ’¬ Not a member yet? Check the Future of Coding Community

āœ‰ļø Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

šŸŽ™ļø Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2024/08 Week 1

2024-08-05 10:21

šŸŽ„ The future of programming is data-parallel? šŸ’” A modern and executable specification language šŸŽ„ Spatial Canvases: Towards an Integration Domain for HCI

Two Minute Week

šŸ’¬ Marek Rogalski

šŸ§µ conversation

Another major feature implemented - the toolbar . I really love the toolbar system used by Vlojure. I never used it personally but I like the idea of many customizable bars. Eventually I'd like to make this one more flexible as well... The animations behave slightly differently than most docks I know (Cairo, Mac OS) - instead of zooming all nearby elements (in a gaussian-distribution like pattern), only the one under the cursor is enlarged. I think this contrast makes it clearer to which action will be selected by clicking. The radar animation also got some love - it now shows the paths to nearby objects, connection name and animates slightly more smoothly.

šŸŽ„ Video

Our Work

šŸ“ Improving LLM Accuracy with Levlo Languages via Jarno Montonen

šŸ§µ conversation

Did an experiment on improving LLM accuracy with Structured Generation using my stuff: Improving LLM Accuracy with Levlo Languages

šŸ§® Cashflow Profiles and Reserves: Actuarial Terminology I via Declan

šŸ§µ conversation

I'm getting ready to release some actuarial models and outputs that use calculang.

So I made an interactive post to introduce some terms actuaries use

šŸ’¬ John Christensen

šŸ§µ conversation

Here's my work in progress node-and-wire system. It's specifically targeting signal processing related work.

Here, data is all passed between nodes as 1D arrays, so the plots just have the x-axis hardcoded for now. I'm not sure if a pair of x/y array's should be passed together on a single wire, or if they should be passed separately for the most flexibility.

image.png

šŸ’¬ Nilesh Trivedi

šŸ§µ conversation

I will try to reproduce these two papers that suggest program synthesis (eg: inducing new tactics) for AI to solve math problems or the ARC-AGI puzzles:

There's a quite a bit of new math/ML/programming for me to learn here.

Devlog Together

šŸ“ Diagram Compiler Status via Paul Tarvydas

šŸ§µ conversation

Iā€™m in the process of writing a transpiler that spits out Drawware 0D kernel code in various languages (like Python, Lisp, JS, WASM, etc.) from a higher-than-HLL. Iā€™m using a very simple ā€œcircuitā€ to regression test (Larson Scanner, as seen on T.V. Knight Rider). Current status and ā€œworking paperā€: 2024-07-30-Diagram Compiler Status

šŸ’¬ Ivan Reese

šŸ§µ conversation

My basement flooded this week. So that's going to set me back a bit. But, hey, here's a quick update on the two FoC-relevant things I'm floating.

  • DANK WIKI ā€¢ At the last FoC virtual meetup, we talked about setting up a super lo-fi, friendly-to-nontechnical-folks, hackable community wiki. I've got a repo all set up for that locally, and just have a tiny bit more experimentation to do before it's ready to share. All the pages are just simple HTML or MD. There is a build step ā€” wait, stop, don't run away ā€” it's a build step, but it's cool and different!! There's a really simple spec and a short reference implementation. Zero dependencies, less than 100 loc. Everyone is encouraged to port the script into their language of choice and commit that. That way, other people can check out the repo, add some pages, and build it locally without having to conform to whatever ecosystem the build script requires. I'd ideally like to have impls in each of the most common ecosystems right away (JS, Python, Ruby, maybe bash, etc). Finally, the wiki is (for now) going to be hosted on Github, with an action that runs the reference build script on commit, so if people want to edit it via the Github web interface they can. (I'll be liberal with handing out the commit bit). This is going to be a social experiment as much as a technical one. Excited to see how it goes. Hoping to have the initial version of this go live this weekend.

  • LIFE RAFT ā€¢ I'm itching to get cracking on a Slack successor. I'm thinking I'll spin up a dedicated channel, and solicit people to drop in whatever random wishes / ideas / requests / suggestions / advice they feel like offering, so that these can filter in to the design process. I'm also hoping to put together goals for an MVP. This will need to include several things, including but not limited to: visual mockups for the GUI on desktop and mobile, technical architecture, priority features, estimated timeline. I intend to be quite restrained here ā€” I want to make the smallest possible good enough thing.

šŸŽ„ work in progress: building a neural network using code-flow-canvas via Maikel van de Lisdonk

šŸ§µ conversation

Youtube Thumbnail

Hi, Because I want to understand better how neural networks work and can be trained, the best way to do is, is by building a small one from scratch myself and training it.

In this video I show creating and connecting a few neural-nodes together and a show a very small prebuilt neural network.

To be able to do this, I've created 4 new node-types in my visual programming system: neural-input-node, neural-bias-node, neural-node and neural-output-node.. the first 3 output weighted connections. This means that a weight property is attached to the connection and can be changed.. the neural-node and neural-output-node use these weights in there respective calculations.

The neural-node currently uses sigmoid as its activation function.

The neural-bias-node only outputs a value of 1 and the output value of a neural-input-node can be changed. When any of these values are changed, they propagate forward through the network.

In the current example flow, an error is also calculated using an expression node-type depending on the output and expected value.

The white object-node is also a new node-type and can be used to obtain multiple values and output them in a single object.

In the near future I hope to implement a neural network that can be trained with the mnist digit dataset, but I have to do a lot more work before I am at that stage I think.

Reading Together

šŸŽ„ [PLDI24] The Future of Fast Code: Giving Hardware What It Wants via Jamie Brandon

šŸ§µ conversation

Youtube Thumbnail

The future of programming is data-parallel?

Thinking Together

šŸŽ„ Spatial Canvases: Towards an Integration Domain for HCI, with Orion Reed via Paul Tarvydas

šŸ§µ conversation

Youtube Thumbnail

Konrad Hinsen, I just watched Orion Reedā€™s talk youtube.com/watch?v=csGNVaB83Rk, pointed out by Christopher Shank. The talk continuously fired the same neurons in my head as does the phrase ā€œmalleable computingā€. Iā€™m not in that head-space, but, I continue to wonder if thereā€™s a connection ā€¦ (YMMV)

šŸ’¬ Kartik Agaram

šŸ§µ conversation

Prompt for everyone here: to the extent that you think about the Future of Coding or have projects to try to improve things, what problem are you trying to attack? Can you state it in a couple of sentences? Without reference to a solution? Try to be precise about the audience. For example, some problems affect everyone, while others affect only professional programmers, or only researchers who use computers in their work.

My hypothesis is that focusing on problems will help us all find our most promising collaborators in this group. (The next step will be to combat our tendency to be defined by our tools, to let our tools erect barriers that divide and balkanize us. But that's further down the road. For now, let's just "find our homies," the people we share specific dissatisfactions with.)

There are ideas for problem statements in a couple of earlier threads:

But this thread is not for critiquing or analyzing any of those statements. Just add your own, and nothing else.

(It's totally fine to copy statements from these threads. Many of them were arrived at after tons of consideration so it would be surprising if others didn't care about them. Also feel free to synthesize from multiple statements. Just try to get to something crisp and opinionated.)

šŸ’¬ Paul Tarvydas

šŸ§µ conversation

Falsifiable theoryā€¦

Theory: Function-based thinking greatly restricts thinking about FoC.

Test: if this theory is true, then examination of the source code for The Mother Of All Demos will reveal that not all parts of the demo system were tightly inter-connected into a single synchronous, functional blob of design.

How?: Where can we find the source code for TMOAD? If we obtain the source, how can we reverse-engineer the design out from the implementation details? If we can get at the design, we should look for how the sub-units of software are interconnected. We need to examine if the code is designed as many islands of synchrony vs. being designed as just one big blob of synchrony.

Corollary: if TMOAD was designed as many islands of software and hardware, then it is unlikely that anything as interesting as TMOAD can come of building software on computers using only synchronous languages, like Python, Haskell, using concepts such as thread libraries, theorem-provers, etc. [Thread libraries are but assembler-level work-arounds that enable the use of the function-based programming paradigm with languages like Python, Haskell, etc. Theorem provers need single islands of synchronous code, to work]

šŸ“ yesterday's prompt on problem statements via Kartik Agaram

šŸ§µ conversation

Follow-up to šŸ’¬ #thinking-together@2024-08-01: post a single comment with a number from 1 to 6 for every comment but yours in yesterday's thread, indicating how close you perceive everyone else's problem statement to be relative to yours. (And don't read other people's comments before you post yours; that's part of the fun here.)

Here's what the numeric scale means:

  • 1: This is a rewording of my problem statement.
  • 2: This overlaps almost entirely with my problem statement.
  • 3: I care about this problem.
  • 4: This doesn't seem like a big problem.
  • 5: This is fine, I don't think it is a problem.
  • 6: This statement is alien to me, I don't understand it as a problem statement.

Hopefully that makes sense and I haven't missed some major option..

In a day or two I'll collate the results in the attached table. (You're welcome to do so as well; just download the html file and open it in a browser tab, fill in and hit the 'save' button to save a local copy with your edits. Upload it here if you like, that can be an alternative way to give your votes.)

šŸ—’ļø problems.html

šŸ’¬ Jari

šŸ§µ conversation

Hello, I am currently building a lowcode platform for easy and fast backend development. Basically, you write logic using functions which look like excel functions or UDFs. Do you have any opinions on programming using Excel? I have written prototypes many times using it, but main problems have been 1) not being able to use it as a backend 2) more complex sheets are hard to understand and test

šŸ“ the problem statement thread via Kartik Agaram

šŸ§µ conversation

Here's the current state of people's reactions to each other's problem statements. If you haven't added your reactions yet, please consider doing so! If you haven't written a problem statement yet, please do so before reacting to those of others. I know it's a non-trivial bit of work. I tend to open Slack on two windows somehow to jump between šŸ’¬ #thinking-together@2024-08-01 and the problem reaction thread šŸ¤¦ But it does seem like something promising to think about.

I've also included a very rough, very preliminary, very incomplete stab at visualizing clusters of people's problem statements. There's no reason to think this "space" is Euclidean or 2D, so take it with a huge bucket of salt.

The visualization is in no way mapping status relationships. The intent is not to exclude anyone, but a very narrow instrumental purpose of finding opportunities to collaborate. If you need an analogy, a better one might be a star chart. It seems safe to assume we're all light years apart given our track record of collaborating šŸ˜„ This picture is an initial attempt at making a map based on imprecise measurements from a single point. If you spend any time thinking about the map, try to build your own from the raw data to avoid my inevitable biases.

I started out with Kartik at the origin (no objectivity here!) and positioned first my 1s, then my 2s, then 3s and so on all the way to 6s. Then I tried to go through others similarly and resolve tensions in a very rough, very manual way. I might do this a few times to try to get better at it.

Even though this "data set" is almost certainly high-dimensional, a few 1-D relationships popped out at me:

  • Kartik -> Tom + Tom -> Paul = Kartik -> Paul
  • Kartik -> Tom + Tom -> Nilesh = Kartik -> Nilesh

I responded by putting the 4 of us on a straight line. There may be a spectrum here that bridges the incomprehension between the ends.

This sort of bridging of incomprehension is a common pattern. I initially had Ivan as far away from Kartik as Paul . But several connections drew the Ivan / Eli cluster closer. Dany too might be as far from me as Paul , but is just 1 away from Jimmy . Guyren too, but is close to Tom and Dany . So some of these edges have more "tension" than others, and I haven't come up with a way yet to show that.

(I'm currently showing edges labeled 1-3. If we get more data I might need to prune that further. The edges are directional but unfortunately my tool doesn't have arrows.)

Anyways. Add your problem statements and reactions!

šŸ—’ļø problems.html

problems.png

šŸ—’ļø problem-clusters

problem-clusters.png

Content

šŸ“ Calculating Empires: A Genealogy of Technology and Power since 1500 via Ivan Reese

šŸ§µ conversation

Via Jack Rusher on Mastodonā€¦

Calculating Empires: A Genealogy of Technology and Power since 1500

It's an enormous map of illustrations of various advancements toward, within, and around computers. Note that it's wildly horizontal. I tried exploring it a bit on my phone but found that unsatisfying. I recommend using the largest monitor you've got.

šŸ’” Quint: A modern and executable specification language via Jason Morris

šŸ§µ conversation

Just saw Hillel Wayne link to Quint on LinkedIn, and I finally want to try writing TLA+ as a result...

šŸŽ„ Midinous - Non-linear MIDI Sequencer - Official Trailer via Mariano Guerra

šŸ§µ conversation

Youtube Thumbnail

Midinous - Non-linear MIDI Sequencer

šŸ‡ Hundred Rabbits is a small collective exploring the failability of modern tech via Andreas S

šŸ§µ conversation

Hello šŸ‘‹ Future of coding,

I hope you are doing well :)

So I found one of those interesting HN posts:

news.ycombinator.com/item?id=41131181

I hadnā€™t heard of 100 rabbits before :

100r.co/site/about_us.html

The comments in the HN are also very interesting. For me they feel very ~much~ related to the future of coding.

Like this one:

news.ycombinator.com/item?id=41136056

In this respect, their page for hacking baguettes by sun&sea is my personal favourite

100r.co/site/solar_cooking_experiment.html

100Rabbits is like the coming true of Grothendieck's 1972 permatech lecture given at CERN*

github.com/Lapin0t/grothendieck-cern

"I think that agriculture, stockbreeding, decentralized energy production, medicine of a certain kind, very different from the medicine that prevails today, will come to the fore. It's impossible to say which part purely creative joy will play in these new developments. My hope is, it will be a creative development in which there will be no essential difference between conceptual activities and manual physical activities. When people become masters of their own needs to the point where an appreciable part of their creativity remains free---and this will take a time we can't predict, it may be a generation, it may be ten, no one knows---at that point, anyone, not just a certain scientific elite, will be able to devote a significant part of their time to purely creative, purely speculative, purely playful research"

šŸ“ this slimy interview via Arvind Thyagarajan

šŸ§µ conversation

apropos of verbalising favourite problem statements, I found a wonderful one in this slimy interview

How can we align our interests with what living organisms and systems naturally do? How can we yoke ourselves to what theyā€™re doing so that our relationship is no longer exploitative, but rather one where weā€™re putting existing capabilities to productive ends?

šŸ¤–

šŸ“ Argentina to use AI to stop crime before it happens - UPI.com via Paul Tarvydas

šŸ§µ conversation

Argentina to use AI to stop crime before it happens

Argentina has announced plans to use artificial intelligence to predict crimes before they're committed, the country recently announced.

Present Company

šŸ“” webrtcforthecurious.com via Guyren Howe

šŸ§µ conversation

Currently trying to use WebRTC from Flutter. I just want a way to find my external IP address and port, and to share data through it. Seems like a simple requirement.

I am utterly astounded at the complexity of WebRTC. Iā€™ve just never see anything quite like it. The Flutter plugin just flat doesnā€™t work for me, and there is no debugging information available to let me know why. The plugin uses an opaque C library, and Iā€™m no C hacker.

Iā€™m down to using a headless browser, which Iā€™m pretty sure I will get working. But holy moley. This: webrtcforthecurious.com is about the friendliest introduction I can find.

Tragic, because ad hoc peer-to-peer connections should be a large part of the Future of Computing.

File under: hopefully not the future of computing.


šŸ‘ØšŸ½ā€šŸ’» By šŸ˜ @marianoguerra@hachyderm.io šŸ¦ @warianoguerra

šŸ’¬ Not a member yet? Check the Future of Coding Community

āœ‰ļø Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

šŸŽ™ļø Prefer podcasts? check the Future of Coding Podcast

Contents Ā© 2024 Mariano Guerra - Powered by Nikola