✉️ Not subscribed yet? Subscribe to the Newsletter

Future of Coding Weekly 2024/07 Week 3

2024-07-15 06:46

🚰 Visual Stream Processing System 🖌️ Figma meets VS Code 🛸 esoteric.codes

Two Minute Week

🎥 Stock Multi Time Series, Atom/RSS and HN Stories using Steampipe via Mariano Guerra

🧵 conversation

Youtube Thumbnail

📈 Stock Multi Time Series

🛜 Atom/RSS

🍊 HN Stories

Data integrations using steampipe.io

💬 Marek Rogalski

🧵 conversation

I've implemented the flip-flop object which concludes the "object library" that is necessary for basic macro playback. Automat can now play Super Mario Bros with only occasional desync issues 🙂

🎥 video

Our Work

📝 Baby's second wasm compiler via Jamie Brandon

🧵 conversation

Very present-of-coding, but the future is coming.

🎲 github.com/ivanreese/2222 via Ivan Reese

🧵 conversation

🎲 I created a new programming game. It's called 2222. (Pronounced "two twenty-two two")

Well, I actually created a meta -game — because you have to program the game yourself , in any programming system you want. Then you get to play it.

The code is incredibly simple. You can do it in 3 blocks of Scratch. It's what TodoMVC would be if it had a soul.

It takes about 22 minutes to play. You will very likely burst out laughing while playing. When you finish the game, you will feel utterly bizarre. You can play the game by yourself, or in a group. Good luck, have fun.

I would love to see your implementation, and/or (but especially and ) a video of you playing.

How do you ~play~ program the game?

Instructions here: github.com/ivanreese/2222

🚰 Visual Stream Processing System via Safta Catalin Mihai

🧵 conversation

Hello! I've been working on something in my spare time, very early stage... but I think it shows promise.

Given that Lu Wilson encourages us to share scrappy fiddles, here it is.

It's a visual stream processing system - based on tldraw for the UI and Pekko Streams (in Scala) for the backend.

Link to the blog post above, and leaving just a gif here as a tl;dr:

1280x720px image

🖌️ Spectral: Figma meets Visual Studio Code via nith

🧵 conversation

Hi everyone! Currently working on Spectral, a new way to approach code navigation by using an infinite canvas for traversal. We are aiming to simplify the onboarding, navigation and debugging processes.

🎥 Spectral Demo

📝 A short parable about technology via Stefan Lesser

🧵 conversation

In the last few days, there have been 💬 #thinking-together@2024-06-15 few 💬 #thinking-together@2024-07-04 here that have inspired me to write this short parable about programming and technology. Let me know how you feel about it. 🙂

🎥 Schema Studio Cursor Dev Update via Dominik Jančík

🧵 conversation

Youtube Thumbnail

I have been working on adding Keyboard / Gamepad only navigation for Schema Studio, the open-source integrated creative environment for light control, generative visuals and more based on vvvv gamma.

The environment focuses on instant feedback, quick editing, using a fun (subjective :)) game like interface. It uses a Block based programming approach that tries to combine the best of text and visual editing interfaces.

I am calling the feature "Cursor", and here is a short demo.

If you're interested in learning more about the tool, head over to schema.scenic.tools

Any feedback and questions welcome :)

Devlog Together

💬 Kartik Agaram

🧵 conversation

I've been slowly reading "The Nature of Order" by Christopher Alexander and slowly thinking about how to make my editor for text and line drawings more timeless. (And mostly sleeping a lot, if I'm honest.) Today the combination of the two led me to draw this shape for the line-wrapping algorithm.

Until now I've been developing the editor the "usual" way, which for me consists of needing some computation, figuring out the most convenient place to perform the computation, then squirreling away the result somewhere it's available when needed. In an effort to get myself out of the rut of the inevitable problems of indirection and cache invalidation that result, I've been trying to replace all my ad hoc data structures with on-demand computation based on the base state of the program. And what I've been ending up with is umpteen variations of this pictured algorithm, just with different code stuck on to the protrusions.

There may be an abstraction that comes out of all this, but I don't see it yet. And as CA says, a flower isn't made up of identical petals. Each one evolves uniquely as a part of the whole.

20240710_175623.jpg

💬 Kartik Agaram

🧵 conversation

Quick and dirty prototype of the above algo/shape/code using Vim syntax highlighting.

The code in the screenshot is a function to convert a mouse click (mx, my) into the location (line_index, pos) of the character at that point on the screen.

The problem is much of this function is boilerplate shared with several other places, such as the code to draw text on screen, compute the height of a wrapped line, etc. The boilerplate makes it difficult to see the business logic unique to this particular function, and so creates pressure to prematurely create an abstraction to "DRY things out". Highlighting the shape of the boilerplate in pink helps the eye to focus to the unique business logic in the protrusions, and so counters the pressure to hide the boilerplate before I've figured out the best way to do so.

linewrap-vim.png

🎥 exporting from codeflowcanvas to open-canvas draft spec via Maikel van de Lisdonk

🧵 conversation

Youtube Thumbnail

Some updates on my visual programming project codeflowcanvas this week: In this video I show some work I did for the open-canvas working group (ocwg for short): if you go to demo.codeflowcanvas.io/ocwg you can see a window floating in the bottom right, this shows the current flow in the current ocwg draft spec.

I've build the export mechanism using a strategy pattern so that I can also easily support other formats if needed (a basic export to tldraw is already one of them). I hope this helps in developing the new open canvas spec that the ocwg is working on via bi-weekly meetings and a github repo (see various links on canvasprotocol.org).

Lately I am focussing more on embedding and/or integrating codeflowcanvas with other tools and technologies so that it is not running in a silo of its own, and this feature helps with that I think.

This week I also send in a submission to liveprog.org.

Content

🐦 Will Crichton via Mariano Guerra

🧵 conversation

Will Crichton: I'm starting a new group at Brown w/@ShriramKMurthi and @KathiFisler called the Cognitive Engineering Lab. We build tools to make you smarter, grounded in cognitive science and programming language theory. And we're hiring PhD students!

If you know browser-based UI programming inside and out (eg, you could reimplement React or Svelte), let's build the PL of your dreams to make reactive UIs fast & correct. Or let's build the next LaTeX / Markdown!

🛸 esoteric.codes via Ivan Reese

🧵 conversation

Just discovered the mostly-defunct blog esoteric.codes. Some beautiful projects on display here.

🎥 Seeing Like a Programmer - Resiliency, Limits, And Moral Hazards In SE by Chris Krycho via Chris Krycho

🧵 conversation

Youtube Thumbnail

Mostly lurking and reading everyone else’s links, but I at last have somethign to share myself! Here’s my LambdaConf 2024 talk, which I think folks in here will appreciate! In this talk: Peter Naur’s “Programming as Theory-Building”, Donella Meadows’ Thinking in Systems , and James C. Scott’s Seeing Like a State .

Graphics

💡 screamer: the playground for screamer, a live-coding language for ray marching via Charlie Roberts

🧵 conversation

a small frp-ish dsl I made for live coding ray marchers: charlieroberts.github.io/screamer/playground

🤖

📝 Neural Operator: Learning Maps Between Function Spaces via Nilesh Trivedi

🧵 conversation

Neural operators generalize neural networks from learning mappings between finite dimensional Euclidean spaces or finite sets to mappings between functional spaces: Neural Operator: Learning Maps Between Function Spaces

Here's a TED talk about how it's being applied in science and engineering: AI that connects the digital and physical worlds


👨🏽‍💻 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/07 Week 2

2024-07-07 23:22

📑 Programming languages resources 🔨 Breaking Silos 💡 The Interfaces With Which We Think

Two Minute Week

💬 Marek Rogalski

🧵 conversation

This week in Automat was mostly refactoring and bug squashing so not much to show. Except today I've sat down and designed the object that will act as a flip-flop switch. The first three images are the candidates for the final object. I'm actually still not decided which one to go for... The others images are just interesting results obtained from prompting stable diffusion

design-generated-20240705-164409-0-detailed realistic masterpiece best q.png

🧵 more images in the conversation

Our Work

📝 The proof is in the meta-tracing JIT interpreter via Mariano Guerra

🧵 conversation

The one where I implement a native JIT interpreter for my minimal oop language using pypy's meta-tracing compiler toolchain

In the previous posts: Make Your Self and Macros and optimizations: it's just a phase I described the design and implementation of a minimal object oriented language with the implementation done in...

🥞 toy postfix stack-based language to inflict upon my kids via Beni Cherniavsky-Paskin

🧵 conversation

Been a while since I touched it but I've been building a toy postfix stack-based language to inflict upon my kids. My theory is:

  • postfix may have benefits for early teaching (linear evaluation order, lack of "syntax", trivial notional machine)
  • the obvious drawbacks can be somewhat mitigated if instead of destructively changing the stack, you can navigate all previous stack states. (I'm not the first to try the latter; in particular Kartik did it in Mu, including descending into function calls. I don't even have user-defined functions yet.)
  • I wanted to explore "replacing" some uses of control structures with composition of a bigger data type, like a whole picture or animation.

I'm resigned to the thing not being turing-complete.

Initial implementation's data type was 1D "animation" of color change (I wanted them to program an RGB lamp)

=> My kids liked typing and mixing colors, but the idea of a single value representing change over time went entirely over their heads 😞

Anyway terminal REPL was a dead end, because you can't go back and edit past code. => I got a prototype web editor — you can move cursor, edit freely, and see stack state before each word: animation-stack-language.netlify.app

TODO: rendering still uses styled block characters 🧑‍💻, I need to learn canvas...

TODO: Next big step will be to replace the data type from 1D "time" to 2D "picture", taking inspiration from forthsalon.appspot.com and code.world .

I'm thinking to make do with some 2D rather than RGB colorspace, so that every pixel can also be interpreted as a vector. That way any picture doubles as a limited representation of function-as-data (not turing-complete! but very visual 🤔).

🎥 hash references to functions, effects and transpilation in EYG via Peter Saxton

🧵 conversation

Vimeo Thumbnail

Hash reference to every function and limiting effects at the top level to allow code to execute even after a failure. This is a bit longer as I try to explain in more detail what these features are in EYG

🧮 Visualizing Risk – Calc with Dec 🧮 🤓 via Declan

🧵 conversation

I made a blog post about visualizing risk

It's a scrollable explanation that develops up a visualization - a bit going on in it, a problem I have with a lot of things, so was really glad to spend time learning a few things about making this kind of scrollable interaction to more carefully introduce things.

Behind the scenes, the numbers are from a calculang model doing monte carlo simulations on a pension calculator calculang model. This composability (or what I call flexibility) is something I decided not to make this post about, but it's an important part of why calculang exists.

I plan to do a few similar separate exercises, and then spin back to this on it's own. (e.g. next: benchmarking actual results to their older estimates)

So, this blog post isn't really technical, but I hope it's interesting or at least easy to follow, and it fits into a longer piece about calculang. Happy if you have any feedback about the post or questions about this longer piece!

Visualizing Risk: feat. a pension savings calculation, Monte Carlo simulation, and ‘scrollytelling’

🤖 A Voice Controlled G AI Assistant for LabVIEW via Jim Kring

🧵 conversation

Making more progress on AI assisted visual programming (with voice control).

🎥 GAIA Voice Demo

📲 DIPLOMATIC: Data sync framework via Mason

🧵 conversation

I've been building a sync framework that app developers can integrate, to securely sync state changes between clients. I call it DIPLOMATIC, after the concept of a diplomatic bag which travels through foreign territories, but protected against inspection. So far I've got a couple host implementations targeting Deno and Cloudflare (Workers + Durable Objects + D1), as well as client libraries to build web clients in React and CLI tools in Deno.

The attached video shows off a demo app that displays and updates a consistent status message across clients. It generates and stores a cryptographic seed (synced via the browser's password manager), queues status changes when offline or not connected to a host, then pushes queued changes when connected, and receives real-time updates using WebSockets.

I've got some rough docs up at diplomatic-docs.replit.app, and a walkthrough of the demo app from the video at diplomatic-docs.replit.app/docs/demos/status.html.

The backstory is that, for a while I've wanted to build a grand life-planning app, like a TODO list that can operate at the decade-level rather than the daily-level. But I kept running into these blocks:

a) I'll want to access it from phone and desktop, so it needs a sync solution,

b) maintaining servers is a pain, and

c) a life-planning tool will necessarily have personal info, so it shouldn't hang out in plaintext on someone else's computers.

These sorts of issues aren't unique to this tool. In fact, I think they're common enough to merit a general solution. The Web 2.0 client/server model gave us easy software updates and access from multiple devices with consistent data. But we backslid by making all app data visible to the software provider and relying on them to maintain their servers. Mobile apps gave us the additional expectation that we could access our data while offline.

I think there's a simple solution to get the best of all worlds, by encoding app state changes as objects (the Event Sourcing pattern), then encrypting those deltas and shipping them off to a server which relays to other clients, which then decrypt and apply the changes locally. With this architecture, the relay servers all have a standard interface (not application-specific), and they're blind to delta contents, so hosting becomes a commodity. This means companies could specialize in just running these hosts, giving application developers a secure backend without the maintenance burden. It also creates a standardized import/export format for app state—the delta log, so you get a backup format for free.

I'm only designing around single-user apps at the moment. Having a "last-wins" policy for conflicts makes things nice and simple..

If anyone knows of related work I should check out, has suggestions, wants to collaborate, ... let me know. The code is still a bit messy, but I'm planning to tidy that up and open the repo soon.

🎥 diplomatic-status-demo

🐸 Todepond dot com: I went to an algorave via Lu Wilson

🧵 conversation

i wrote up my experience of slowly discovering the live coding world, and how my Arroost tool fits into it, and the motivations for my work

🖥️ A set of tools to play around with a Hack compute via Ignacio Brasca

🧵 conversation

Hello everyone! I have just finished a set of tools I built while learning about the Hack computer architecture. Today I felt confident that I could share all the code I wrote for this

To me, this architecture was a great starting point if you want to get a hang of how computers, compilers, and virtual machines actually work

Devlog Together

💬 Kartik Agaram

🧵 conversation

Shower thought on yesterday's thread above: the painter's algorithm is a way to make an interface less stateful. It lets you specify shapes to draw in any order. However:

  • It does this by adding more state to the implementation. You can't just draw each shape as you encounter it in the code. You have to shove them all into an array, sort by z value, and then draw them all.
  • It does this by adding more state to the communication channel. The human has to provide a z value now for each shape. Sometimes this is naturally obtained, sometimes it is not and the human now has to think in their heads about what z value to give their shapes to make the drawing come out as they want.

Thinking about this, it feels like state is to some extent inevitable. There's some conservation of state going on. You can't really eliminate it. You squeeze it down in one area and like a balloon it pops up somewhere else.

🧑‍💻 a visual notation for something we typically use keyword args for. via Kartik Agaram

🧵 conversation

This morning I'm thinking about turning 💬 #devlog-together@2024-06-30 into a visual notation for something we typically use keyword args for. For example, the following glyph might represent a function for initializing a text editor widget with the following signature:

edit.initialize(top, left, right, bottom, font_size)

And the numbers indicate a specific call to this function:

edit.initialize(15, 15, 115, 215, 20)

visual-keyword-args.png

🤔 moving away from slack via Ivan Reese

🧵 conversation

This week, I'm learning more WebGPU, since I'm hoping to use it for a handful of visual programming projects down the road. I'm also still looking at options for 💬 #administrivia@2024-06-24. Would love to find something that feels more like a forum than a chat, but not toooo much like a phpbb, and doesn't have a per-user cost, and doesn't impose a maintenance burden, and is accessible to search engines (and accessible to all people, natch), and isn't likely to "incredible journey" or "we AI'd every text field for you" etc. So we're currently whatever the opposite of "spoiled for choice" is :)

Reading Together

📝 Weird Machines, Exploitability, and Provable Unexploitability via Polly

🧵 conversation

I've been kinda obsessed with this paper, "Weird Machines, Exploitability, and Provable Unexploitability" since October last year.

🎥 RuhrSec 2018: "Keynote: Weird machines, exploitability and unexploitability", Thomas Dullien

(I think starting with the talk is a good idea)

After hearing about robust first computing I've been pondering the connection for a bit. I'm not really sure what to make of it, but there has to be some connection. In this talk by Dave Ackley he specifically mentions that "flipping one bit" (paraphrasing) can be enough to destroy a lot of software, which is the exact attack model that Dullien uses. It would be nice if software could maintain security invariants despite memory corruption (which Dullien proves for a small piece of software that he writes) so in that sense the two concepts allign. But I find that "continuing despite an error" or "return a best-effort answer" is the source of many security vulnerabilities, (mid example: database lookup fails, code is written in a way that forgot to handle that case, code continues anyway and returns admin data that shouldn't be shown). I wonder if any of y'all have read this or have thoughts about it. :))

Thinking Together

💬 Declan

🧵 conversation

I recall coming across some opinions Against interactivity. I think in support of showing the thing, rather than making the user interact to see the thing.

Is there a soundbite for this? Are there any good links? I don't know where I encountered this opinion I think a few times, but I found something in one passage searching Bret Victors Explorable Explanations.

I wonder is this the most concrete link or reference I'll get, or does it ring a bell for someone else?

image.png

💬 Shen Li

🧵 conversation

I find a lot of statements these days describes a fact about something and then call it the “best”.

It’s like someone saying “look number 2 is so great, it’s the only even prime number, it’s so cool that it’s used as the base of digital systems, so we should use 2"

And someone else says: “well, number 3 is cool because it’s the first Mersenne prime, and it has a super cool divisibility rule, so we should use 3”.

At the end of the day, if the question is 1+1, then 2 is infinitly better than 3, and the other way around if the question is 4-1. And if you just need some positive integer as a placehold or something, then well, they are the same.

People seems to like and re-post these information a lot. I think these facts do provide some values, like the whole entertainment industry, it fulfills the curiosity of our minds and keeps us, well, entertained.

But drawing the conclusion that something is better, or something should be used instead of another thing based on these facts just feels off to me. It’s especially bad IMO, when people use these statements in PR reviews.

💬 Eric Normand

🧵 conversation

I have a question I hope someone here can answer. I am at something of a crossroads in my career and privileged enough to be able to pursue almost anything. When I tell people the big problems I'd like to make an impact on, it's education, specifically science education. I want more people to understand how the scientific method works and how we use it to gain more understanding.

I have passively read about education (Montessori, Bruner, Piaget, Pappert), followed Alan Kay and the smalltalk story, and I was a math teacher for a couple of years. I also teach currently online.

I can't help but think that there is more to using computers than reproducing old media, and that the code-debug cycle is a good way to refine our understanding. And so maybe there is something there, using programming and interactivity as a medium for exploration of ideas.

However, I don't have much more of a vision than that. I was talking to my wife about it yesterday and came up with an interesting phrasing: I want to do what Montessori did with her learning materials but with computers as a medium.

I would appreciate any and all links to people, conferences, reading material, etc., that are related to this idea.

Just to be clear, I don't mean teaching kids to code. And I don't mean using software to support the current educational paradigm (e.g., Chromebooks in schools, etc.). People seem to automatically roll back to those two pits.

I'm in pursuit of the next part of my career. I don't know what it will look like, but I want it to be productive.

💬 Paul Tarvydas

🧵 conversation

pond’ring aloud:

The value of Gutenberg’s printing press is that it taught kids to read, not to build printing presses.

The value of computers is that they teach kids to ???, not to write code.

💬 Paul Tarvydas

🧵 conversation

pond’ring aloud:

I wonder if the problem with VPLs is the word “language”.

It appears to me that the word “programming” has been generally accepted to mean “sequential language” or writing sequential codes (aka “coding”). I view this view as being too restrictive. Programming is more than just commanding a machine with sequentialistic instructions. Programming a CPU , though, is - by definition - sequentialistic. But,,, programming a machine(s) need not be sequentialistic. Especially in the age of nothing-is-central. In fact, LLMs are an example of non-sequentialism. The machines that run LLMs were programmed, arduously, in sequential notation, but, the inner success of LLMs is not sequential, but something else (massively parallel plinko?).

VPLs and DPLs are, to me, not sequentialistic things. Maybe they should be called “notations” instead of “languages”? VNP and DNP? Visual Notation for Programming, Diagrammatic Notation for Programming? [In which case, “programming languages” as we know them, are TNPs - Textual Notations for Programming].

In fact, programming is not the difficult part. Re-programming is the novel aspect of Design that computers bring to the world. We have been programming machines to do single things for centuries (using metal lathes, etc.). This time through, though, we have built machines capable of doing many things.

💬 Shen Li

🧵 conversation

Related to my last post, where I believe we shouldn’t make decisions outside the context of a problem or goal.

I’ve observed the same issue with secondary goals, where they are discussed outside the context of primary goals.

I don’t know if this bothers other people, but it bothers me a lot. Maybe I’m not smart enough to see the implied connections.

One example I can give is that many times I’ve been given the goal of “consistency,” whether in the UI or the code style. I’m not saying “consistency” is a bad thing, but without connecting it to the primary pre-shared goal, the value of this secondary goal becomes trivial and nullified. Logically, it doesn’t make sense either, especially for a start-up, because a start-up is doing something new, and you can’t do new things by pursuing consistency. If we did things consistently, we’d still be using XML instead of JSON.

Again, to be clear, I’m not saying doing things consistently is bad. I’m just saying that, for me, when given the goal of “consistency” without the context of why it’s important for our primary goal, I’d be much more motivated.

Another example is “patterns.” I think initially “patterns” are just solutions to some pre-existing problems, but we put too much emphasis on them to the point where we forget about the goals of these patterns, and the patterns themselves become the goal. To be clear, I’m not saying patterns are bad or that we shouldn’t use them. We should know them, in the same way we should know other just-in-case knowledge, to perform better. Some patterns are just cool, and we derive joy from them, the same way we get joy from movies and music. I’m just saying we probably shouldn’t treat them as primary goals (unless in school, I guess, where you get points for implementing a pattern).

Now that I think about it, this may just be a communication issue within an organization, where secondary goals are communicated without the connection to primary goals. I’ve never worked in a big organization, and I wonder how they do it. Also, am I alone in this? Do other people feel demoralized too when given just a secondary goal?

Content

📑 Programming languages resources via Mariano Guerra

🧵 conversation

This page is a collection of my favorite resources for people getting started writing programming languages.

🔨 Breaking Silos via Mariano Guerra

🧵 conversation

Breaking Silos by Gilad Bracha

Experiment: AI assisted summary edited by me to pique your interest (let me know what you think):

  • Modern applications are siloed and have difficulty cooperating with each other.
  • This was not always the case, exemplified by the Apple Newton, a mobile device released nearly 30 years ago.
  • Apps on the Newton were written in NewtonScript, a prototype-based language.
  • Newton applications had a flexible top-level view, enabling app compositionality where entire apps could be nested within others.
  • Objects in NewtonScript (called frames) inherited properties from both their prototype and their parent, facilitating UI use.
  • This inheritance allowed an app to function as a widget inside another app, enabling dynamic interaction between nested and enclosing apps.
  • Apps on the Newton persisted their data in object stores called soups, which were accessible by multiple apps.
  • The concept of co-designing language and UI existed earlier, exemplified by the Boxer system from the 1980s.
  • Another example of compositionality is Morphic, a graphics system developed in Self and later adapted for Squeak and Lively Kernel, focusing on graphical structure rather than application logic.
  • Inspired by Morphic, the idea of an app store with composable apps was proposed about twenty years ago.
  • These apps would live-update, synchronize automatically, and be local-first, a concept predating Apple's app store.
  • Newspeak language derived partly from this effort.
  • A practical example of app composition is in travel, where a button for weather lookup could be embedded into an itinerary and dynamically interact with surrounding widgets to display relevant weather information.

💡 The Interfaces With Which We Think via Mariano Guerra

🧵 conversation

The concepts in modern operating systems — apps, windows, desktops, notifications, and so on — have so permeated our understanding of personal computing that it’s hard to imagine anything else, let alone believe there could be anything better.It’s easy to assume that this is, somehow, simply, how computers work .

But this can’t be further from the truth.

🎥 progrium technology thesis 2022 via Ivan Reese

🧵 conversation

Youtube Thumbnail

Revisited Jeff Lindsay's 2022 thesis video and, yep, it still kicks ass.

🧫 cell thingy via Lu Wilson

🧵 conversation

Incredible project: "cell thingy" inspired by CellPond and MarkovJunior

🐦 Tweet from @x via Duncan Cragg

🧵 conversation

x.com/_rygo6/status/1809346180650004992

I replied to this point mentioning my unshakeable belief in what I am doing, and it occurred to me that there aren't actually many on this FoC Slack who can equally say that they know exactly what they are certain is right for the Future of (Programming)! We get a lot of speculative and experimental thoughts here which is the reason we all engage, but who amongst you can say you are 110% certain you've found what you believe to be the Future, with the uncertainty only being in "whenever that comes about"? Which of course, as the Twitter thread mentions, is about the seemingly trivial but of course 110% important factor of "memeing" to the Internet. Personally, I'm crap at that bit.

📑 Ashley Blewer's Halt and Catch Fire Syllabus via Walker Griggs

🧵 conversation

A CFL (call for links). Does anyone have any other examples of non-academic syllabi like Ashley Blewer's Halt and Catch Fire Syllabus? Specifically a curated, self guided exploration of a topic that references foundational academic works but is itself not created as a formal course. That vast majority of syllabi online are (under)grad syllabi reposted by the department or professor


👨🏽‍💻 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/07 Week 1

2024-06-30 22:19

🔌 Is an AI copilot for LabVIEW possible? 💾 Local, first, forever 🎥 Future of Coding virtual meetup #2

Two Minute Week

🎥 Working on live notation systems with spatial computing for our lil robots… via Alex McLean

🧵 conversation

A bit more progress with hand-drawn code. Towards the end you can see there's a bit of abstraction going on

Our Work

📝 Macros and optimizations: it's just a phase via Mariano Guerra

🧵 conversation

Macros and optimizations: it's just a phase: The one where I implement macros and optimizations as a sequence of evaluations with different semantics

💁 is this 🦋 homoiconic?

💬 Hamish Todd

🧵 conversation

I posted a longer version of this above, but I don't think I introduced it very well! It's a stab at Stop Drawing Dead Fish in VR with spreadsheets and something called Geometric Algebra (GA) also known as Clifford Algebra.

Those who have scrutinized Stop Drawing Dead Fish(SDDF) closely might have noticed two references to GA. Bret also used to have a "Geometric Algebra" sticker on his laptop! But while GA is a very Bret thing, he actually did not use it to make SDDF, so my thing is trying to make good on that.

GA is a mathematical system where you get a bunch of geometric objects and transformations, and they all get related to one another by math that is quite a lot simpler than usual. For example, in the conventional/non-GA approach, if you wanted a line in 3D space you'd take two "vectors" v1 and v2 and say the line is the set of vectors v1+t*v2 for all scalars t. This can be kinda useful, but gets complicated if you ask for a simple thing like a rotation around that line. In the GA way of doing things, instead of being "a set of vectors", a line is its own sort of object - lines can be added together; multiplied by planes and rotations; etc. Lots of useful operations turn out to be examples of this, I've attached a pdf of examples.

"doing math/programming by working directly with (tangible/visualizable) geometric objects instead of with linear equations" should strike you as a centrally Bret thing. But why didn't he use it? I'll say in a comment under this message.

🎥 Video

🎥 Exploring Technique and Notations for Augmenting DX via Paul Tarvydas

🧵 conversation

Youtube Thumbnail

FTR: Here is the demo video I presented earlier today. I've added links, in the form of a Kinopio page, to the other technologies that I didn't demo.

Exploring Techniques and Notations for Augmenting DX

💬 Paul Tarvydas

🧵 conversation

In my demo, I made the statement "... t2t doesn't need the full power of OhmJS ...", but, I didn't clarify.

For t2t - text to text transpilation - primarily, you need to pattern-match incoming text, then emit text based on the input.

OhmJS parses incoming text, then gives you the full power of JavaScript to do anything you want with the parse tree.

For t2t, you don't need to resort to class hierarchies, functions, closures, etc., etc. You primarily need to pattern match, then, create and modify text. In addition to OhmJS' ability to pattern-match, Javascript's "template strings" are about all you need - the ability to create text and to interpolate text from the tree walk of the parsed input.

This seems to be unnecessarily restrictive, but, turns out to be quite powerful and mind-freeing. Fewer options -> less clutter -> increased ability to think about interesting issues. After all, "simplicity" == "lack of nuance", and, my goal is to simplify DX.

[Infrequently, one needs to do a tiny bit more (like gensym() a new symbol and leave it on a scoped stack for use during the tree-walk), so I provide a way to break out and call a Javascript function, but, this kind of power is not needed in most cases. I guess that, in the future, I will restrict this some more, but, I'm still experimenting].

🔌 Is an AI copilot for LabVIEW possible? via Jim Kring

🧵 conversation

I’m close to publicly releasing an AI powered coding assistant for LabVIEW, a visual programming language. Here is a teaser

🎥 Video

🐸🎥 Reaction Reaction via Lu Wilson

🧵 conversation

I did a four hour livestream performance art piece where I explore the nature of recursion and infinity and time. And it starts with me doing some crappy live coding

Reaction Reaction

Devlog Together

🎥 Embedding codeflowcanvas and exporting to different formats via Maikel van de Lisdonk

🧵 conversation

Youtube Thumbnail

In this video you can see the progress I made on opening up codeflowcanvas so that it is embeddable in other frameworks/libraries like Astro/Angular and React. I've restructured some of the packages that the project uses and published these to NPM. You can see the embedding of codeflowcanvas on its own website using a custom StorageProvider for loading json files from a javascript bundle: codeflowcanvas.io/devlog/embedded-codeflowcanvas .

This goal of this restructuring is to get codeflowcanvas out of its own silo on various way (for example in the future I want to be able to design flows in a vscode editor and use these together with other framework/libraries without embedding the editor and just run the flows).

A feature that is also made possible by the above is being able to export to external formats like tldraw and the OpenCanvas work-in-progress spec (see canvasprotocol.org). Different strategies can be implemented to provide different formats.

Thinking Together

💬 Ivan Reese

🧵 conversation

I'm becoming interested in the idea of "programming tools as art", and as a consequence I'm interested in programming tools criticism.

I'd like to read/watch/hear critical reviews of programming tools that approach them not as bundles of features and capabilities, but as authored works that reflect a creative intent and as cultural touchstones and as environments or artifacts within which one can have deeply personal experiences.

A. Do you share my interest?

B. Do you know any such critics?

💬 Alex McLean

🧵 conversation

Who'd be interested in an event with talks and some performances around making notations and programming languages for pattern-making (textile, musical, choreographic etc)? Half focussed online, half focussed in-person, all streamed. Mix of open call and invited talks. All free/open access. Probably in January. Maybe called "Programming Of The Art Computer".

💬 GuzhIRegem

🧵 conversation

Hey, someone knows about any research into RAG-Based training of models?

Content

🎥 Is it really "Complex"? Or did we just make it "Complicated"? via Paul Tarvydas

🧵 conversation

Youtube Thumbnail

Alan Kay talk ‘Is it really "Complex"? Or did we just make it "Complicated”?’. The talk was given some 9 years ago, but, this is the first time that I’ve seen it

My highlights:

51:21 suppressing the present to see different ways to address the future

51:35 “semaphore” is a “bad idea”, pseudo-time is superior, but never got used over last 30 years

54:10 Nile Graphics Language by Dan Amelang is a dataflow language and is very small. Expresses how to define shapes using pixels in only 45 lines of code.

54:51 - Bret Victor at VPRI

57:59 all compositing rules, including alpha-blending, is expressed in 95 LOC

59:16 whole graphics system, equivalent to what is needed on a PC, is expressed in 435 LOC

1:01:00 - Code has to be transformed into CPU-speak

1:01:38 - we need a “language transforming language” [[pt] At present, I use the term “t2t” (text to text)]

1:01:58 - OMeta2 [[pt] OhmJS is an ancestor of OMeta2]

1:02:58 Using OMeta to make Nile, parser 130 LOC, LLL 730 LOC

1:06:00 TCP/IP expressed in 160 LOC

1:20:24 POLs == Problem Oriented Languages [[pt] I use the term SCN - Solution Centric Notation]

1:37:37 hardware is just software that is crystallized early [[pt] I say it another way: software is just soft hardware]

💾 Local, first, forever via Nilesh Trivedi

🧵 conversation

On Interoperability of sync services for software designed to be Local-First

📝 Programming in “Abstract G” via Jim Kring

🧵 conversation

Here’s an article I wrote on a visual dataflow language modality where the execution of the graphical dataflow dynamically constructs the dataflow graph that is itself executing. (It’s similar to how Elixer functions can output AST for the function instead of the result and one can alternate between AST via quote/unquote)

Music

🎥 Detailed walk-through and explainer via avon

🧵 conversation

Youtube Thumbnail

ran into this strange and wonderful physical modeling synthesizer called Anukari which has a lot of lovely 3D VPL concepts in its interface design

The dev also did an ADC talk and there’s a lot of interesting computing going on under the hood, like using the GPU to do all of the physical modeling math: Fast Audio Thread Synchronization for GPU Data - Evan Mezeske - ADC23

Logic Programming

💬 Jason Morris

🧵 conversation

What would the syntax be for searching any statement that includes the atom socrates ?

Present Company

🎥 Virtual Meetup 2 • June 26, 2024 via Ivan Reese

🧵 conversation

Youtube Thumbnail

Recording of last week's Future of Coding virtual meetup #2


👨🏽‍💻 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/06 Week 4

2024-06-23 23:27

🎙️ Future of Coding 72 • Pygmalion 🎥 The Alternate Reality Kit 👓 We Need a Super Cockpit for the Mind

Two Minute Week

🎥 Explaining effects with EYG via Peter Saxton

🧵 conversation

Vimeo Thumbnail

Trying to explain effects better with EYG

⏺️ new Macro Recorder object was added this week via Marek Rogalski

🧵 conversation

A new object was added to Automat over the last week - it's the final one that is needed for the MVP to work. And it does work! I've recorded myself writing a small C++ program and the macro recorder replayed it correctly ^^

I guess I'll start posting Automat updates to Mastodon :) Here is the first one - a new Macro Recorder object was added this week!

Our Work

🐟 Future of Coding 71-VISION • This is not a fish via Lu Wilson

🧵 conversation

Youtube Thumbnail Here it is... the Future of Coding's first official video adaptation.

This is This is not a fish

🎙️ Future of Coding 72 • Pygmalion by David C. Smith via Ivan Reese

🧵 conversation

If you're anything like me (oof, sorry), you've heard of Pygmalion but never caught more than the gist. Some sort of project from the early 70s, similar to Sketchpad or Smalltalk or something, yet another promising prototype from the early history of our field that failed to take the world by storm. Our stock-in-trade on this show.

But you've probably heard of Programming by Demonstration. And you've certainly heard of icons — you know, those little pictures that have become indelibly part of computing as we know it. Pygmalion is the originator of these concepts… and more!

The best introduction to Pygmalion is Mariano Guerra's No-code History: Pygmalion, which includes a clearly articulated summary of the big ideas, motivation, and design, with a video demonstration of the programming interface, key terminology, and links.

The most introduction to Pygmalion — or Pig Million, The Millionth Pig, as it'll surely come to be known — is the subject of today's episode: the original paper by David Canfield Smith.

🐢 Make Your Self via Mariano Guerra

🧵 conversation

Make Your Self: In Search for Maxwell's equations of OOP

My attempt at growing the smallest object oriented language step by step, let me know what you think!

📝 Just Some Innocent Gradient Fun - Untested via Rafał Pastuszak

🧵 conversation

Some Innocent Gradient Fun (explaining how to apply shading via noise + posterise in SVG)

Hi there! This one will be quick. Let's let the code speak for itself for a change. innocent-gradient-fun.webp A week back or so I saw a video by a channel called Texture Labs explaining a simple sha…

Devlog Together

💬 Oleksandr Kryvonos

🧵 conversation

🎥 Flying chars

Reading Together

🎥 The Alternate Reality Kit via Marek Rogalski

🧵 conversation

Youtube Thumbnail

I've just learned about Alternate Reality Kit. I've searched through the archive and it was mentioned in passing a couple of times but I don't think this article was ever posted: Experiences With The Alternate Reality Kit An Example of the Tension Between Literalism and Magic . There is also a relatively recent video upload (video comes from 87 but it was uploaded only three years ago) which shows a more mature version in action: The Alternate Reality Kit .

Its similarity to the system that I'm developing is just uncanny! I'm very interested in learning more about it. I tried to follow its history to figure out why it was abandoned but I've only been able to track that its development eventually led to the Self language (Self and Self: Whys and Wherefores) which honestly seems like a step back from the original. I have my theories about why it might have been abandoned (which is that educational software is hard to sell) but would love to learn more about it from the people who might know more. Or maybe there are other systems that might have been derived from it?

🎥 Self and Self: Whys and Wherefores

Self and Self: Whys and Wherefores

💬 Konrad Hinsen

🧵 conversation

I don't know, but I have my hypothesis as well as for why this and other user-empowering approaches were abandoned: the rise of PCs. In the late 80s and early 90s, the first PCs appeared and were seen as the obvious road to computing for everyone. But they were not powerful enough to run environments like Smalltalk. It's Basic we got instead. In parallel, professional high-end computing grew as well and that's where the money was. Academia followed the money.

Thinking Together

💬 Oleksandr Kryvonos

🧵 conversation

Builders manifesto (aka* Software builders manifesto )

Build as much as you can, experiment as much as you can, build something you are passionate about.

*- I just created this manifesto, so it is a bit of overstretch on the “aka” part 😄

Content

📝 Achieving Self-Sustainability in Interactive Graphical Programming Systems via Shalabh Chaturvedi

🧵 conversation

@Joel Jakubovic’s thesis should be interesting to folks here.

Achieving Self-Sustainability in Interactive Graphical Programming Systems Programming is fraught with accidental complexity. Software, including tools used for programming, is inflexible and hard to adapt to one's specific problem context. Programming tools do not support Notational Freedom, so programmers must waste cognitive effort expressing ideas in suboptimal notations. They must also work around problems caused by a reliance on plain text representations instead of Explicit Structure.

The idea of a Self-Sustainable programming system, open to adaptation by its users, promises a way out of these accidental complexities. However, the principles underlying such a property are poorly documented, as are methods for practically achieving it in harmony with Notational Freedom and Explicit Structure. We trace the causes of this difficulty and use them to inform our construction of a prototype self-sustainable system. By carefully reflecting on the steps involved in our specific case, we provide insight into how self-sustainability can be achieved in general, and thus how a motivated programmer can escape the aforementioned sources of accidental complexity.

Future of Coding also gets a shout-out:

I must express my gratitude to the Future of Coding Slack channel for making me aware of Tomas’ PhD opportunity in late 2018

👓 We Need a Super Cockpit for the Mind (History Talk) By Tom Furness via Justin Janes

🧵 conversation

Youtube Thumbnail

🐘 epic mastodon thread via Ivan Reese

🧵 conversation

This epic mastodon thread has some interesting reflections on Pygmalion.

📝 Christopher Alexander & Center for Environmental Structure Archive via Stefan Lesser

🧵 conversation

For those of you interested in Christopher Alexander’s work: The Christopher Alexander & Center for Environmental Structure Archive is live. Here's an excerpt from Maggie Moore Alexander's announcement:

This new website gives access to 50+ years of work by Alexander and colleagues at CES. The goal of this continuing endeavor is to share the work with all who wish to build and repair living environments in which people thrive. In total, the Archive includes some 29,000 items. About 50% of them have been catalogued to date and are listed on the website. Around 6000 items have been digitized and are now available from the website as downloads. As funding allows, we will work toward making the whole collection available.

🤖

🎥 Autocomplete for infinite canvas - Lu Wilson - tldraw - AI Demo Days #1 via Nilesh Trivedi

🧵 conversation

Youtube Thumbnail

Lu Wilson’s AI demo for TLDraw: youtube.com/watch?v=01yE-vzJ-NE

Present Company

💬 Ezhik

🧵 conversation

have you ever done a project where you added an embedded programming language for scripting, configuration, fun, etc? what's your go-to choice for the language? why?


👨🏽‍💻 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/06 Week 3

2024-06-16 22:21

🎥 Snappets: Procedural Animation for children (in VR!) 🧮 iPadOS "math notes" 💡 Some possible goals for the future of software

Two Minute Week

💬 Marek Rogalski

🧵 conversation

Things are moving again in the right direction 🙂 This week two new objects got finished - the Timeline and the Key Presser. Just one more and the MVP will be complete ^^

🎥 Video

Our Work

🎥 HypoTalk: Let's put JavaScript back in the event handlers via Mariano Guerra

🧵 conversation

Youtube Thumbnail

A demo of HypoTalk, a live environment to develop and compose UIs with the least amount of logic possible.

🎥 Snappets: Procedural Animation for children (in VR!) via Hamish Todd

🧵 conversation

Youtube Thumbnail

Hey folks, a video of the mathematical animation program I've been working on!

📝 You Are A Coder (zine) by enderverse via ender

🧵 conversation

“End users” are always already programming. I made a (digital) zine about this.

Devlog Together

💬 Oleksandr Kryvonos

🧵 conversation

very small update to my new project (name selection pending)

🎥 Demo

Thinking Together

💬 Oleksandr Kryvonos

🧵 conversation

A spreadsheet with the FoC projects

💬 ender

🧵 conversation

I am currently thinking about working on one or more of these ideas:

  • visual pl for creating your own compiler
  • visual pl for spreadsheet creation and customization
  • visual pl for making domain specific languages

I will probably converge on a visual programming language with a spreadsheet GUI that compiles to WebAssembly. Any resources for intuition about compilers, spreadsheets, or DSLs that help me understand these topics would much appreciate.

(think: x explained visually, explorable explanations)

💡💬 Kartik Agaram

🧵 conversation

Some possible goals for the future of software

After some 💬 #linking-together@2024-06-06 discussions, I spent some time searching the archives of this community for the word 'manifesto', then skimming the manifestos I found in search of their goals, phrased as problems they saw in the world. Then I clustered them by these problems. Here's what I ended up with, possible problems we have seen in the past:

If the problem you're chasing doesn't quite fit in any of these buckets, please share it in a similar format. (One sentence, not describing a solution.) If it does fit one or more of these buckets, please mention them. (Alternative wordings are also appreciated, but for me the primary goal here is to cluster ourselves.)

💬 Don Abrams

🧵 conversation

we keep telling computers how to work instead of what they should do

Content

🐘 Explorable explanations for great good via Kartik Agaram

🧵 conversation

🧮 iPadOS "math notes" brings some spreadsheet/Calca mechanics to handwriting via Beni Cherniavsky-Paskin

🧵 conversation

Oh, and they even added Bret Victor style variable "scrubbing".

(Desktop also got builtin Math Notes, minus handwriting, briefly flashed 51:57 — looks very much like Calca.io / Soulver / NoteCalc etc.?)

So, are we "Magic Ink" yet? (I'm not so much thinking of Bret Victor's essay as Ink&Switch's experiments like inkandswitch.com/inkbase, CrossCut & Untangle ...)

On one hand nothing revolutionary, spreadsheets had much more power for decades.

And yet a solid chunk of useful functionality is starting to move into taken-for-granted "this is just how futuristic paper naturally works" territory 👏.

I expect long term it might make such "what-if" explorations accessible¹ to more people, and more importantly prepare people for more complex interactions on top?

¹ well, once/IF it waters down to lower-end hardware. Good-enough stylus tech remains expensive enough to be niche, not evenly distributed 😞

💬 Alex McLean

🧵 conversation

I always thought field was well ahead of its time. Prefigured a lot of Bret Victor's demos and future of coding work that followed in 'real world' use.. Happy to see it is still active. Has anyone used it?

🤖

📝 arcprize.org via Nilesh Trivedi

🧵 conversation

This is an AGI benchmark where LLMs currently perform 34%. A prize has been announced for the first team to reach 85% performance: arcprize.org

Present Company

💬 Iacob Nasca

🧵 conversation

anyone around here working in a R&D department ? I need some pointers. Thanks!


👨🏽‍💻 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/06 Week 2

2024-06-09 23:09

߷ Where Unison is headed 💡 Ruminating about mutable value semantics 💚 FoC Demos

Two Minute Week

💚🎥 Lustre on Gleam tours via Peter Saxton

🧵 conversation

Vimeo Thumbnail

I made a project to have lots of concepts explained in Gleam tours. Gleam runs in the browser and server so I think that this might be a good platform to explain a lot of things. I've been showing Gleam to non programmers and they mostly "get it" as long as there is no installation, editor setup, deployment to worry about. My current though for the future of code is that no-code might be less important that no-ops.

💚🧑‍🏫 Welcome to lustre - The Lustre tutorial via Peter Saxton

🧵 conversation

I finished implementing my first tutorial quicker than I expected. You can try it here. gleamtours.com/lustre-tutorial/introduction/welcome-to-lustre It's a walk through creating a web app with Gleam and Lustre. The app is rendered in a separate window because future tours will allow you to implement a client and server and so the sandbox can't just be an element in the tours UI.

An interactive introduction and reference to the Gleam programming language. Learn Gleam in your browser!

💚🎥 Gloodata Wikipedia Components: Summarize, Infobox and Tables via Mariano Guerra

🧵 conversation

Youtube Thumbnail

New Wikipedia plugins for gloodata

Short demo showing the three new Wikipedia plugins (Summarize, Infobox and Tables) and how they integrate with existing ones to get information about a thing or a place.

💚🐦 Marek Rogalski (@mafikpl) on X via Marek Rogalski

🧵 conversation

Eh, I've just spent 5 hours doing high-school-level math just to draw a couple slightly curved lines =_= [

🐦 Marek Rogalski (@mafikpl) on X: Today cables in Automat improved their routing a bit! I'm pretty disappointed with the pace but at least it's going forward...

Tweet Thumbnail

Our Work

💡 Ruminating about mutable value semantics via Jamie Brandon

🧵 conversation

Still just ruminating in public, but I swear there is an actual compiler taking shape

📝 What is agile? via Jase Pellerin

🧵 conversation

I wrote a post about leveraging the raw core of agile to help focus attention and make cool shit. I plan to dig deeper and discuss more tools in future writing, but I would love any feedback!

📝 Relational programming simple use Case via Paul Tarvydas

🧵 conversation

Just in case someone else finds this useful, here is a small case-study of a relational program written in Prolog, from another conversation.

🎥 Simon & Tudor chatting about Moldable Development via Tudor Girba

🧵 conversation

Youtube Thumbnail

Simon Wardley and I had a chat about Moldable Development. It talks about programming through custom tools (by which we mean thousands of tools per system).

Perhaps it’s interesting for this community as well.

💚🎥 Context is all you need: Add previous actions as context to new prompts via Mariano Guerra

🧵 conversation

Youtube Thumbnail

Context is all you need: Adding previous actions as context to evaluate the current prompt and avoid repetition.

Thinking Together

💬 Oleksandr Kryvonos

🧵 conversation

I am sorry to interrupt , and this may sound like a question with an obvious answer,

but what are the goals we are trying to achieve? What are the problems we are trying to solve ?

Content

߷ Where Unison is headed · Unison programming language via Mariano Guerra

🧵 conversation

Where Unison is headed by @Paul Chiusano

This is a long post with a lot of details of what we're thinking for the future, so here's a summary:

  • Keep keep improving the core language, runtime, and tooling. Examples: adding an FFI to Unison, improving JIT compiler performance, more semantic merge capabilities, and a more graphical UCM experience.
  • Make Unison Share an even nicer place to host your projects. Examples: "find usages", site-wide code search, multi-collaborator projects, and more.
  • Major new Unison Cloud features: scheduled jobs, distributed event processing, resilient workflows, and high-performance native execution via our JIT compiler.

🐘 Lu wilson 🏳🌈 (@TodePond@mas.to) via Lu Wilson

🧵 conversation

an interesting back and forth thread between me and Kartik Agaram on mastodon about how to build "better computing"

🎙️ :arne-brasseur (tea, travel, taoism and HoC) by Lost in Lambduhhs via Tim Schafer

🧵 conversation

So this is going to be more of drive by random act of gratitude non-sequiturs smorgasbord, but I’m pretty sure y’all like overtone, and I will link, so that’s the bit right? So in all my scrubbing of recent podcast listenings and reading of show notes I forked (don’t you mean formed? No, no, there was the potential future timeline of consciousness, and this is the fork) a much deeper appreciation for the plethora of references so lovingly strewn throughout the show.

This was all to no avail in locating one wild goose of a phrase saying there was renewed effort on making overtone more useable so people can do cool shit. For a while I could swear it was Ivan’s voice I heard saying it. Well, it was actually the end of a different podcast. Perhaps the wires that got crossed were FoC and HoC. The important thing is that the supercollider of my mind has been thoroughly re-patched. And for that I thank you all! Also Clojure is cool. That’s my Ideology :)

Now back to my ~reading~

Links: Arne - https://github.com/plexus Heart of Clojure - https://2024.heartofclojure.eu/ Overtone - https://github.com/overtone/overtone

Keywords: Arne, Belgium, Lambda Island, , Clojure Camp, gaiwan, travels, tea, Europe, United States, cooking, gardening, circus arts, juggling, flow state, European Juggling Convention, Taoism, self-awareness, mindfulness, narcissistic spirituality, teaching, leadership, empathy, vulnerability, Heart of Clojure, community conference, holistic experience, software industry, software engineers, activities, workshops, interactive sessions, keynote talks, open source contributors, contributor onboarding, Leuven, Belgium.

Music

🎼 Studel v1.1.0 is up! via Alex McLean

🧵 conversation

Web-based environment for live coding algorithmic patterns, incorporating a faithful port of TidalCycles to JavaScript

Present Company

📻 Donate to Digitizing "The Famous Computer Cafe" radio show, organized by Kay Savetz via Mariano Guerra

🧵 conversation

Digitizing "The Famous Computer Cafe" radio show

Help digitize 54 episodes of The Famous Computer Cafe, a 1980s radio show about computers that featured many notable interviews.

💬 David Alan Hjelle

🧵 conversation

Two related questions:

  • Is there any good research about using call graphs to create some metrics about the quality of a software architecture? (Since I've never looked into it — what's the state-of-the-art in measuring software quality, anyhow? I'm more interested in a quality architecture than bugs-per-line-of-code or something, I guess.)
  • Any favorite tool for visualizing call graphs for JavaScript or PHP?

My intuition would tend to say that messy call graphs indicate a worse architecture, but I haven't visualized many and I'm not sure how well that idea holds up in the "real world". Maybe call graphs end up being too messy in real programs.

🛸 Come gush about the Connection Machine with me. via Ivan Reese

🧵 conversation

Come gush about the Connection Machine with me. Share your anecdotes. Tell me what *Lisp was actually like. Marvel at a time when computers still looked futuristic.


👨🏽‍💻 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/06 Week 1

2024-06-02 23:16

👓 Exploring Spaces 📝 Interactive study of queueing strategies 💚 Many project updates

Two Minute Week

💚🎥 Adding ports dynamically, new sum node and integrating a basic Monaco editor via Maikel van de Lisdonk

🧵 conversation

Youtube Thumbnail

In this video, I start with building a simple flow which counts the sum of all received values on the input ports using the new node-type "merge sum". New ports can be added dynamically from within the UI.

This is used to simplify the PID-controller example, which now much more reflects the algorithm that is shown on the wiki-page.

I've also started integrating the monaco-editor (which is the base for vs.code) into code-flow-canvas.. and in the video you can see that it is used for editing the code behind the iframe-html-node.

Another small change, is that flows now start automatically when they are loaded or after a refresh.

Our Work

💚💬 Mariano Guerra

🧵 conversation

How do you update your password in gloodata?

The same way you do everything else

gd-update-password.gif

👓 Exploring Spaces 4.5: 3D Rotations via Elliot

🧵 conversation

I made a 3D rotation explorer and I also made a big mistake in the explorer and I also fixed the mistake and now it is all good lol! Check it out and let me know what you think 🙂 vezwork.github.io/polylab/dist/demo/articles/exploring_spaces_4_and_a_half

🎥 Video

💚🧮 calculang.dev via Declan

🧵 conversation

I decided to make a pass at actually putting technical information on the calculang.dev frontpage.

My primary audience for calculang.dev is developers - due to the wide scope, I think this is important (and Steve Balmer, right?).

Other projects based on/around calculang will have a wider audience.

It's the first time I surface some information: about introspection output to help to make tools that interact with models, about a comparison to spreadsheets, a rough note about my visualization APIs. I'll expand on all these things in longer-form separately and add illustrations for some concepts (especially "flexibility"), but for now, I think it's important I have some things down that I can iterate on, and happy to hear any immediate feedback, especially about what lands especially poorly or doesn't fit! (since this is a community of developers, your feedback would be awesome for me to get to work)

I intend to push the Examples to a Gallery or Playground page instead, with just a more subtle carousal or such surfaced early in the main page

🖼️ github.com/bicycle-codes/image-element via nichoth

🧵 conversation

Hoping this is the last time I will have to write this.

💚🎥 Improved structural editor via Peter Saxton

🧵 conversation

Vimeo Thumbnail

I think this is structural editor V3. this one is back to having all navigation be AST based, i.e. up tree down tree, there is no moving cursor ability

💚💻 ReSheet via Daniel Krüger

🧵 conversation

I officially promoted ReSheet from alpha to beta!

ReSheet has undergone a lot of detailed work over the last two months that might not be noticeable unless you encountered specific issues that got improved.

Noticable will be the improved starting document which makes it much clearer what ReSheet aims to achieve and how to use it. I added a demo, better documentation, and several examples. The examples aim to demonstrate what's possible with ReSheet and the potential I see in it. I think the "Examples > Custom Blocks" and "Examples > Interactive Game Dev" pages will be especially interesting to you.

"Examples > Custom Blocks" illustrates how to integrate almost any other (web/React) library/tool. I think there’s a lot of potential if we could integrate the various tools developed here. Since many are web-based, ReSheet could potentially serve as a framework to unify them. If anyone is interested in exploring this, please send me a message! 🙂

"Examples > Interactive Game Dev" showcases the possibilities for building custom Blocks in ReSheet. It uses built-in Blocks to create a simple interactive Game Editor, featuring live programming and displaying intermediate steps/results of the code.

Let me know what you think!

📝 From Spatial to Parallel Reality Computing via Duncan Cragg

🧵 conversation

Hiya, I've published another article, which says pretty much the same as before, but consolidates some ideas and brings things up-to-date:

The magical mashability of Parallel Reality Computing...

💚🎥 Raycasting in calculang, with formulas, interactivity & explainer via Declan

🧵 conversation

Youtube Thumbnail

I made a video explainer about raycasting, using a new experimental environment for calculang

Devlog Together

💚🪵 lazer cutting box joint generator Observable notebook via Tom Larkworthy

🧵 conversation

Had fun presenting my lazer cutting box joint generator Observable notebook at Germany FoC meetup. Feel free to DM me or leave a comment in the notebook if you want to chat more about it. I dunno how well I communicated the point, but my point is that you can solve harder problems if you can link representations. There is no representational hierarchy of best-ness, I am finding switching between representations is useful for getting the best of all worlds. The notebook contains some cool advanced observable hacks, like projecting the inbuilt "plot" data visualizer onto three.js surfaces, linking quantitive DataViz to a Spatial representation, both of which have different strengths.

🎥 dice into reality

image.png

✏️ github.com/uprun/GRAIL-like via Oleksandr Kryvonos

🧵 conversation

This is super-early announcement.

Since I could not find something similar to GRAIL developed by Rand corporation - I am starting my own - GRAIL-like system.

Currently only simple drawing on canvas is implemented - I plan to add basic symbol recognition next.

Code is here github.com/uprun/GRAIL-like

I am using Godot game engine for this.

🎥 Video

Thinking Together

💬 Jason Morris

🧵 conversation

In something like prolog, terms can be nested. So I can express the idea "Socrates believes that he is mortal" with bel ieves(socrates, mortal(socrates)). Are there any popular database types that make it easy to have relations of arbitrary arity as parameters of other relations, without unduly adding to the complexity of the schema? Preferably with ungrounded statements and open-world negation? Is there some obvious reason why not? Is there a computational complexity problem that arises in the real world? RDF allows triples to be referenced, I believe, but you are limited to arity 2, which seems needlessly limiting. Labeled graphs have arbitrary arity for non-entities, but entities are limited to two, and you usually can't refer to an edge. It seems... weird to me. Is it just that we don't really have the efficient reasoners over those kinds of expressions, so it hasn't been useful?

💬 Peter Saxton

🧵 conversation

What conference would people recommend, preferably ones still to happen this year, which are a good place to discuss FoC topics

Content

📝 Queueing – An interactive study of queueing strategies – Encore Blog via Mattia Fregola

🧵 conversation

Really lovely interactive exploration on queueing

In this blog, we go on an interactive journey to understand common queueing strategies for handling HTTP requests.

🎥 Verse Update I State of Unreal 2024 via Dany

🧵 conversation

Youtube Thumbnail

In this sponsored talk we take a look at the latest Verse features and what's coming soon to the language and framework.

📝 Sheet Happens via Mariano Guerra

🧵 conversation

But until I put the numbers in and tried to write about them… I did not know what I was trying to count, or what it would be possible to count. The spreadsheet is not a neutral tool of objective social quantification: it is the story of my research process.

🕸️ Graphs, Metagraphs, RAM, CPU via Nilesh Trivedi

🧵 conversation

This paper argues that Metagraphs are simpler and more efficient to represent graph data.

Present Company

💚🎥 FoC Virtual Meetup via Ivan Reese

🧵 conversation

Youtube Thumbnail

Recording of last week's Future of Coding virtual meetup


👨🏽‍💻 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/05 Week 4

2024-05-26 23:13

📡 Propagator Networks 🌯 Visual Language for Polymorphic Types 🤨 NoCode Will Not Bring Computing to the Masses

Two Minute Week

🐚 Automat via Marek Rogalski

🧵 conversation

Context: Automat aims to be a general purpose visual shell - it's meant to control other apps & pass their data around. It has a website at automat.org. The MVP version is going to record & replay desktop macros. Last week I've pretty much finished the work on connections and now I'm working on the new timeline object!

Automat is a FOSS software that allows anyone to control their computers by combining interactive blocks.

🐦 Marek Rogalski (@mafikpl) on X: Working on the most complex Automat object so far - the Timeline. It should be able to control other objects according to its embedded tracks.

Tweet Thumbnail

🎥 PID controller build with codeflowcanvas via Maikel van de Lisdonk

🧵 conversation

Youtube Thumbnail

In this video I show a PID-controller build with my visual programming system codeflowcanvas.io ... the PID-controller example can be found on demo.codeflowcanvas.io.

It uses expression nodes, global variables and flow-variables to handle the calculations and state. In a bar-chart the output of the mechanism can be seen. In this example the target value is 100 , and when moving the input value slider, that value is used as a measurement and the algorithm brings the measurement to the wanted value (100). This process is visualised in the bar-chart.

When the speed of the flow is set to maximum (in the top left corner), the "program-counter"-animation is not shown and it runs as fast as it can in realtime. That helps for these kind of algorithms.

Our Work

📡 Propagator Networks via Dennis Hansen

🧵 conversation

Hello! So after much obsession with Propagator Networks as discussed on this slack 💬 #thinking-together@2024-03-21, i decided to make a little propagator network simulator on top of tldraw.

In short: Propagator networks enabling bi-directional computation via independently operating nodes- in the gif you can see one for converting temperatures. Propagators (squares) listen to changing inputs, run code, and update connected outputs.

You can make your own here.

  • Put your variables in circles

  • Put your JS in squares (you can write a return or not)

  • Draw arrows from circles to squares with text that matches the variables

  • Draw arrows from squares to the circles to be updated.

There's lot of awesome stuff than can be made with these (maybe everything?). If you want to have fun with it, try to make a conditional or a switch. Its fun 🙂

Cheers!

ezgif-2-f1371da04b.gif

💬 Kartik Agaram

🧵 conversation

🧵 for Cole Lawrence's demo today.

💬 Mariano Guerra

🧵 conversation

🧵 for Maikel van de Lisdonk's demo today.

💬 Mariano Guerra

🧵 conversation

forgot to share this in the demo

gloodata-inception.gif

Devlog Together

🤖 github.com/nileshtrivedi/autogen via Nilesh Trivedi

🧵 conversation

I have started porting Microsoft's multi-agent framework "autogen" to Elixir: github.com/nileshtrivedi/autogen

Got basic multi-agent collaboration and code execution working. Now need to make Elixir functions available to agents as tools.

I feel Elixir will become more and more important for AI because of its excellent support for real-time communication (audio/video etc), and single-language stack (LiveView etc.)

Reading Together

🌯 GeckoGraph: A Visual Language for Polymorphic Types via Don Abrams

🧵 conversation

Beautiful study on a visual representation of abstract types (Haskell in this case but generalizable). Conclusion: intuitive and helpful for beginners, but distracting GeckoGraph: A Visual Language for Polymorphic Types

Thinking Together

💬 Stefan Lesser

🧵 conversation

This is one of those questions where I don’t really know yet how to ask it, so let me fumble and handwave a little bit and see where this goes:

In computing history we went from printers to screens, and on those screens from a brief stint with vector graphics to bitmap displays, and on those bitmap displays from text mode to frame buffer, and in those frame buffers from sprites and blitting to rasterization and compositing. In the early days, when there wasn’t enough RAM for a full-screen bitmap frame buffer, character glyphs and sprites were brought in from ROM. Now we have so much memory that we have double-/triple-buffering and realtime compositing of separately stored textures that often exceed the number of screen pixels available by an order of magnitude or more.

I’m particularly interested in the early transition to raster graphics. At some point (and I assume that was probably with PostScript?) it became feasible to compute graphics on the fly instead of having them prepared as bitmaps in ROM or on disk. If I remember this correctly, PostScript was invented because due to the different font sizes it was more economical to ship instructions to generate glyphs on the fly on the printer than to ship all possible glyphs as bitmaps in all the different font sizes.

In a way we went from a “final” representation of a map of bits restricted to a certain grid size to an “intermediate” representation of instructions that have to be executed to generate the final map of bits in the desired size. Alternatively, we could see that as swapping space (memory) for time (compute).

Are you aware of any papers or other material that compares both sides of this transition?

For instance in terms of performance in space and time, ie. how much compute is needed for how much memory saved. Or in the broader sense of how we settled on certain graphics primitives, because they were cheap enough to implement in terms of compute, and how we settled on certain data formats, because they were small enough in terms of memory usage, so that this trade-off made sense.

🎥 Grail Demo from CHM tape via Oleksandr Kryvonos

🧵 conversation

Youtube Thumbnail

Does anyone know if there is somewhere a new implementation of something similar to GRAIL system from Rand corporation ?

Content

🕸️ Dify's new workflows feature via John Choi

🧵 conversation

Has anyone tried using Dify's new workflows feature?

It seems to be a Node-RED-like visual programming tool that supports Python/Node scripting in addition to HTTP requests and LLM invocations for nodes.

(The parent app (Dify) is clearly positioned in the AI domain, but the workflows feature seems pretty general.)

I'm looking into it but also interested in hearing others' initial impressions/assessments of limitations 👀

🤨 NoCode Will Not Bring Computing to the Masses via Mariano Guerra

🧵 conversation

It's not enough for a tool to solve your problem for you to use that tool. You have to also A) recognize the problem you have is solvable, B) recognize the tool can solve it, and C) be reasonably confident that you personally can solve the problem with the tool. You need knowledge, skill, and the right mentality. Even programmers, who already have that mentality, don't automatically generalize it to all applicable domains. Otherwise we'd be doing a lot more with our phones.

It's unreasonable to expect the average person will use any NoCode to solve their problems, regardless of how easy the tools are. This leaves the people for whom it provides economic value, which is why all modern NoCode tools are oriented towards business.

📝 FORTRAN Report 1954 via Marcel Weiher

🧵 conversation

And of course “no code” and “lo code” are just new versions of “code”. Well, the ones that work at least.

My favorite quote on this topic encapsulates it nicely: “Since FORTRAN should virtually eliminate coding and debugging…” — FORTRAN Report 1954


👨🏽‍💻 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/05 Week 3

2024-05-19 23:29

💻 Bend: a parallel language 🎥 New Graphical Programming Language for Audio Research & Developers 💡 The Alternative Implementation Problem

Our Work

🪩 Exploring Spaces 4: Sphere via Elliot

🧵 conversation

I've made an article about 🌐 spheres and input spaces that wrap around like spheres 🌐. Let me know how it feels to move around the spheres. Does the way they are synchronized make sense? vezwork.github.io/polylab/dist/demo/articles/exploring_spaces_4

image.png

💬 Jared Forsyth

🧵 conversation

Hi friends! As part of my unending pursuit of creating The Best Programming Language, I've ended up building a structured editor / literate programming environment for creating self-hosted languages ... and that has turned into "An Interactive Tutorial about Compilers & Type Inference", that includes interactive implementations of the papers "Algorithm W Step by Step" and "Typing Haskell in Haskell" (with more planned). I'm currently looking for beta testers to look it over before I make a general release, and I imagine there are many people here with relevant experience 😄.

So if any of y'all are interested, send me a message! As a teaser, here's the start of the intro document:

image.png

Devlog Together

💬 Jason Morris

🧵 conversation

Got to a major milestone in v2 development for §Blawx, this week. The visual code editing environment is now back to feature parity with v1, which means I can move on to re-implementing the reasoner on the back end. That's the last major obstacle before I can start doing some much more compelling neuro-symbolic AI demos.

Reading Together

💬 Jacob Zimmerman

🧵 conversation

Has anyone worked through “Software Foundations”, and did you find it valuable?

Thinking Together

🐦 Tweet from @swardley via Konrad Hinsen

🧵 conversation

In this tweet , Simon Wardley compares making software systems explainable via moldable development (my expansion of his reference to Glamorous Toolkit) to creating maps. That sounds like a very useful metaphor to me. Many of us are interested in or even working on visual coding tools, and I wonder what their take on this metaphor is. Maps are inherently visual, but they are not the territory, i.e. the code with all the details. To me, visual tools are obviously the right choice for creating maps, but I remain unconvinced about their appropriateness for code.

I am thinking in particular of Orion Reed’s recent demo of infinite canvasses as user interfaces. For making multi-faceted maps to software systems, that looks like a very appopriate representation.

🕹️ The 100 Games That Taught Me Game Design via Mariano Guerra

🧵 conversation

Youtube Thumbnail

An interesting video: The 100 Games That Taught Me Game Design

I would like to see "The 100 Applications That Taught Me Application Design".

Which ones are yours?

💬 Daniel Sosebee

🧵 conversation

Loose set of thoughts:

  • could you make a type system that somehow captures all information possible about every value in a codebase? Like where the following is true: if typeof(a) === number, then typeof(a + 1 + 2) === number+3 !== typeof(a) …
  • I might want to “pin” and “unpin” my types - e.g. before refactoring a function, to “pin” its return type. If I had a more powerful type system like described in part one, I wouldn’t want to have to write out the whole type, I would want to just say “pin this such that whatever changes I make could not possibly effect the outcome of the function for any input, or else give me errors describing exactly what part of the input space no longer maps logically the same to the output space”
  • Another way to think of this might be to say, rather than writing tests, to be able to say “assume infinite test coverage of this codebase (and all tests are passing), now let me refactor things”.
  • I have no idea how this would work, but it makes me think of getting fractions into “simplest form”. Maybe you could get two functions into “simplest form” to test their similarity?

I wonder if anything like that exists, or if this is gesturing at some existing area of research?

Content

💡 The Alternative Implementation Problem via Mariano Guerra

🧵 conversation

The Alternative Implementation Problem

What I’ve concluded, based on experience, is that positioning your project as an alternative implementation of something is a losing proposition. It doesn’t matter how smart you are. It doesn’t matter how hard you work. The problem is, when you build an alternative implementation, you’ve made yourself subject to the whims of the canonical implementation. They have control over the direction of the project, and all you can do is try to keep up.

🪤 Inside the Cult of the Haskell Programmer via Mariano Guerra

🧵 conversation

Inside the Cult of the Haskell Programmer

That Haskell never gained widespread adoption exemplifies a paradoxical truth in software engineering: Great programming languages aren’t always great for programming.

📑 Damaged Earth Catalog via Konrad Hinsen

🧵 conversation

Damaged Earth Catalog

We are humans and might as well get used to it. So far, remotely done power and glory—as via government, big business, formal education, church—has succeeded to the point where gross profits obscure actual loss. In response to this dilemma and to these losses a realm of intimate, community power is developing—power of communities to conduct their own education, find their own inspiration, shape their own environment, and share their knowledge with others. Practices that aid this process are sought and promoted by the DAMAGED EARTH CATALOG.

🎥 NO MORE CODE: New Graphical Programming Language for Audio Research and Developers - ChangHun Sung via Dany

🧵 conversation

Youtube Thumbnail

New Graphical Programming Language for Audio

Audio software development is rapidly moving towards incorporating machine learning-based processing. While research scientists are continuously presenting us with inventive results in the field of AI, there is a lack of software engineering tools to utilize these results.

💻 Bend: a parallel language via Mariano Guerra

🧵 conversation

Bend: a parallel language

With Bend you can write parallel code for multi-core CPUs/GPUs without being a C/CUDA expert with 10 years of experience. It feels just like Python! No need to deal with the complexity of concurrent programming: locks, mutexes, atomics... any work that can be done in parallel will be done in parallel.

Twitter announcement (includes a short video demo)

After almost 10 years of hard work, tireless research, and a dive deep into the kernels of computer science, I finally realized a dream: running a high-level language on GPUs. And I'm giving it to the world! Bend compiles modern programming features, including:

  • Lambdas with full closure support

  • Unrestricted recursion and loops

  • Fast object allocations of all kinds

  • Folds, ADTs, continuations and much more

To HVM2, a new runtime capable of spreading that workload across 1000's of cores, in a thread-safe, low-overhead fashion. As a result, we finally have a true high-level language that runs natively on GPUs!

📝 Today they published the workbook that they produced from that research! via Eli Mellen

🧵 conversation

Once upon a time somewhere here, lost to the sands of a freemium slack instance, I shared a link about research some friends of mine were doing through the developer success lab on code review anxiety. Today they published the workbook that they produced from that research!

🤖

💬 Nicolay Gerold

🧵 conversation

Not really sharing but a question for the curious:

What new use-cases do you think are now possible with gpt-4o that weren’t possible before (natively multimodal)?

What use-cases are now possible with way cheaper gpt-4-turbo?

What are you excited to try / build?

I will start: I want to try and build a better screen reader for visually impaired people.

💬 Jason Morris

🧵 conversation

There are some call-heavy agentic or personic processes that are going to get more feasible, like what Park did in "Human Simulacra." I'm hoping to use 4o or turbo to have a more structured step by step approach to code generation in domain specific visual languages.

💬 Chris Maughan

🧵 conversation

What struck me when playing with it via the 'voice chat/conversation' thing, was a) how brilliant the voice recognition is, b) how brilliant the synthesised voice is, and c) how I was drawn into having a conversation with an AI. I don't know if it's a use case, but what I can see happening is that more and more people are going to start treating the AI as a 'friend'. I think that is quite sad, and will further isolate people from real life conversations, but I can also see how it will fill a need in some folks; especially once the iPhone integration happens.

Present Company

💬 Ivan Reese

🧵 conversation

Thoughts and observations from today's Google I/O.


👨🏽‍💻 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/05 Week 2

2024-05-12 22:58

🧑‍🏫 Live Programming for the Classroom 🤖 LLM-focused canvas 💡 Software in Natural Language

Our Work

🎥 DB48X v0.7.5 quick update via Christophe de Dinechin

🧵 conversation

Youtube Thumbnail

The most powerful scientific calculator in the world just got one tiny step closer towards 1.0.

🖌️ Fig via Rafał Pastuszak

🧵 conversation

Hej! I made a drawing app where every pixel has a lifespan and eventually dies, check it out here: fig.sonnet.io

(also it has hackable, programmable brushes and a trippy geocities-eque gradients)

Motivated by a dead fig tree in my garden, not associated with the exquisite dead fish above, and partially inspired by this poem by my brother’s 3yo daughter:

Little ducklings walked

then they fell

and they died.

(something tells me she’ll turn out to be a goth like her uncle)

untested.sonnet.io/Fig

Nothing lasts forever, so let's draw just for the fun of it!

💬 Cole Lawrence

🧵 conversation

I’m making an AI pipeline REPL directly into “Forethink,” and I just put in live previewing, so you can observe individual executions 🙂

I think this will slowly evolve depending on the features we need to build. It’s nice to build purposefully and not need to worry about being too generalizable or pretty.

🎥 2024-05-10-Forethink-placeholder-resolution-for-single-execution

Devlog Together

🎥 Quality of life improvements to code-flow-canvas via Maikel van de Lisdonk

🧵 conversation

Youtube Thumbnail

I've made some very nice UX improvements to the visual programming system that I am working on: it's now possible to replace a node with compatible node-types without hassle. When a node is selected, compatible node-types are shown in a dropdown. This helps especially when doing more creative work when creating a shader/gl flow for example and getting more feeling on what the impact is of certain mathematical operations (in the video youtu.be/K-956F6Vwps I change a multiply node to an arctan calculation).

Another improvement is being able to insert a node into an existing connection.. also taking compatibility into account. This speeds up the creation process of flows in general.

Under the hood I've also made a nice improvement: I can now use jsx components using vanilla DOM without the use of react or other libraries. This is a nice DX improvement when developing my project.

Reading Together

📝 some wandering notes via Pete Millspaugh

🧵 conversation

^I finished the book a while back and just got around to jotting down some wandering notes.

Would anyone be interested in doing a zoom book club discussion? Slack threads per chapter are nice for participation across time zones, but I prefer the format of reading then chatting about the whole book in one sitting

Thinking Together

📝 Banning the use of if Then Else via Paul Tarvydas

🧵 conversation

Thinking about banning the use of IF-THEN-ELSE...

🎥 Bootstrapping Research & Dynamicland, Dec 2019 via JP Posma

🧵 conversation

Youtube Thumbnail

The best Bret Victor talk you've never seen

💬 Andreas S

🧵 conversation

Hello Future of Coding!

I'm looking for something which I would describe in the following way. There was a few years ago a article on hackernews where someone showed a kind of dynamic state transition visualization. One could setup multiple nodes and avalue flow from one node to the next but there would be also a flow back to the original node. So my question would be does anyone know what I refer to? What was the name of the diagram. I tried to search for dynamic state transition diagram but it is very scary how bad search engines are these days. So the Name of the diagram , the hackernews article or related reousces would be most welcome. Thank you 🙂

Content

🧑‍🏫 Seymour: Live Programming for the Classroom via Nilesh Trivedi

🧵 conversation

image.png

💻 github.com/dmotz/trystero via Nilesh Trivedi

🧵 conversation

This seems clever! WebRTC matchmaking over BitTorrent, Nostr, MQTT, IPFS, and Firebase - removing the need for centralized signaling servers for multiplayer real-time webapps.

🤖

🎥 Hunch.tools winning demo at Latent Space's AI UX event in SF via Greg Bylenok

🧵 conversation

Youtube Thumbnail

Couple of links from some recent digital wanderings:

Hunch Tools LLM-focused canvas, from a recent AI/UX meetup

💡 GitHub Next | SpecLang via Greg Bylenok

🧵 conversation

Second link: SpecLang from Github Next, which "is an attempt at lifting the developer experience to a higher level of abstraction, closer to how we conceptually think about our programs"

(Github Next is worth exploring and they appear to be doing quite a bit of FoC-related work)


👨🏽‍💻 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