✉️ Not subscribed yet? Subscribe to the Newsletter

Future of Coding Weekly 2023/12 Week 2

2023-12-10 21:54

🤖 Visual exploration of inference in a LLM 📑 Functional Reactive Programming Resources 🗨️ Conversational UI for Interactive Components

Two Minute Week

🎥 Add and Use Union Kit via Dany

🧵 conversation

Youtube Thumbnail

This week I'd like to show how a new union type is added to miqula. See description under video. (no audio)

Our Work

🎥 Motion Extraction via Chigozie Nri

🧵 conversation

Youtube Thumbnail

I really liked Posy's latest video so I just put a version of the motion extractor on replicate: replicate.com/chigozienri/posy-motion-extraction

📝 chigozienri/posy-motion-extraction – Replicate

Extracts motion from video

🎥 birds

🗨️ Gloodata: An Extensible Conversational UI for Interactive Components via Mariano Guerra

🧵 conversation

First public release of Gloodata: An Extensible Conversational UI for Interactive Components

Builds for Linux (x64) and Mac (Apple Silicon) here: gloodata.com/download

Overview: youtube.com/watch?v=f-txlMDLfng

Let me know what you think!

Gloodata: An Extensible Conversational UI for Interactive Components

🐦 Chigozie Nri (@chigozienri) on X via Chigozie Nri

🧵 conversation

🐦 Chigozie Nri (@chigozienri) on X: These boids are very rude

Tweet Thumbnail

🎥 Parabola

📝 The Wizardry Frontier — Sympolymathesy, by Chris Krycho via Chris Krycho

🧵 conversation

Writing a bit about moving the state of the art—this piece itself isn’t doing it, but I kind of hope this framing is useful for people who are trying to do it.

For 75 years, programming languages have steadily raised the baseline of what “normal” programmers can express in their languages. They can still.

Devlog Together

💻 bugfix: only check for settings menu when open via Kartik Agaram

🧵 conversation

This bug I foisted on myself today was a real "things are not as they appear" puzzle.

🗓️ qemu-advent-calendar.org/2023 via Kartik Agaram

🧵 conversation

So Mu was on the advent of Qemu calendar yesterday, and I totally missed it.

💬 Kartik Agaram

🧵 conversation

Screenshot_20231207_101640.jpg

Screenshot_20231207_101753.jpg

Screenshot_20231207_101610.jpg

🎥 Kinopio To Markdown via Paul Tarvydas

🧵 conversation

Youtube Thumbnail

Status video about Kinopio2md (Kinopio to Markdown). What is not said is that the blue boxes are source code for the app (the compiler compiles the drawings to executable code). I deal with a bunch of different programming languages, picking the best one for each step along the way (approximately 10, if you include English). I want to document more deeply the use of the Transpiler in, say, the “Escape Whitespace” Component (and others), but, I haven’t gotten around to it yet

🫶 Playing with LÖVE's physics engine for the first time via Kartik Agaram

🧵 conversation

I've been making a little program every evening with my new toy. Today:

akkartik.itch.io/carousel/devlog/647726/playing-with-lves-physics-for-the-first-time

🎥 Physics Game

🎥 Advent of code day 7 implemented in my visual programming system via Maikel van de Lisdonk

🧵 conversation

Youtube Thumbnail

Oh boy.. it was a lot of work being able to solve advent of code puzzle 7 (part 1) in my visual programming system.. as you can see in the video youtu.be/kkgJQdJXFtk. I had to implement a lot new node-types for handling dictionaries and a new scoped-variable type. This scoped-variable can have different types.. currently just a regular value or a dictionary. This dictionary is used in a function-flow to determine the hand type which is needed in this puzzle. Also custom sorting was needed (I implemented a Schwartzian transform in the sort node-type). Running the flow for the full puzzle input takes a long time so I don't show that in the video (although I've added a "full-speed" mode that helps a bit). I've also added some colors to better show when some nodes are active, especially handy for nodes that run longer like a foreach, function-call, map or sort.

Thinking Together

📝 Code layout for programming via Paul Tarvydas

🧵 conversation

I believe that VPLs are better than TPLs. I include some observations that led me to that conclusion. meta: I choose to believe that this channel “thinking together” means that half-baked ideas are to be tossed out for brainstorming, pushback, discussion and revision. guitarvydas.github.io/2023/12/04/Code-Layout-for-Programming.html (discussion of 1D, 2D, 3D, 4D program syntax)

Content

🤖 bbycroft.net/llm via Mattia Fregola

🧵 conversation

Pretty awesome visual exploration of inference in a LLM

💻 VSCode LLVM Compiler Explorer via Shubhadeep Roychowdhury

🧵 conversation

This is a tool for compiler developers of LLVM. This vscode extension can support exploring LLVM IR and machine IR after each pass

📑 Functional Reactive Programming Resources via Alex McLean

🧵 conversation

List of Functional Reactive Programming resources:

A chronological collection of academic resources on the practice of functional reactive programming. Great care has been taken to respect copyrights - no files are directly hosted and...

💬 Kartik Agaram

🧵 conversation

This is absolutely fascinating. Tally marks are a little visual language that has coevolved with the textual context.

I don't have a link, but links appreciated.

signal-2023-12-08-07-37-36-166.jpg

🤖

💬 Nilesh Trivedi

🧵 conversation

What if web frameworks offered a standard way to discover capabilities that are then given to AI as tools? A document.getTools() perhaps?

This could be achieved simply with plugins for NextJS, VueJS, SvelteKit etc. Small convention that eliminates a lot of brittleness when web agents try to discover capabilities and invoke them.

image.png

Future of Coding Weekly 2023/12 Week 1

2023-12-03 22:56

👓 VR visual/spatial programming 👁️‍🗨️ Explore, collect & play with live visual programs 🗓️ Adventual activities

Two Minute Week

🎥 Enter a Subnet via Dany

🧵 conversation

Youtube Thumbnail

Last week I worked on entering a subnet, this is used for condition, match, filter, map etc.. See description under video. (no audio)

Our Work

📝 Recursive grammar literals via Jason Priestley

🧵 conversation

Hi all, I've been inactive here for a long time. Progress on my big project, a collaborative mobile-friendly development environment, has been very slow. However, along the way I've built some libraries which may be of interest to some people here.

On the languages and parsing side, I've built recursive grammar literals which lets you write CFGs as normal javascript functions. And church-cat which lets you compute over a tree structure, e.g. annotate a parse tree.

On the UI side I've built imperative which is a frontend javascript library much like React, but based on generators and structured concurrency. And most recently I've been working on Palimpsest which covers the backend of web development with a more functional or "event-sourced" style where data sources are computed as folds over input streams. My interest there is to allow stateful applications to be more easily shared, forked, and extended by their users etc.

🎥 Statecharts papers we love video via Paul Tarvydas

🧵 conversation

Statecharts - my reading of Harel’s original paper in video format (26 minutes) . (In case it’s not obvious, IMO it’s worth knowing about Statecharts, even if you believe that VPLs are a dead end).

📑 wigwam.directory: curated list of small-but-mighty projects via Taylor Troesh

🧵 conversation

Howdy friends! I recently published the beginnings of a new project: wigwam.directory

I'm looking for projects that reduce public reliance on bloated/crumbling infrastructure. Any suggestions?

🌱 The sustainability doughnut of scientific software via Konrad Hinsen

🧵 conversation

I have written a short essay on software sustainability, and I'd love feedback from this community:

The sustainability doughnut of scientific software

It's written in the specific context of computational science, but it readily translates to other application domains.

🎥 Plato Demo Video by Michael Gummelt

🧵 conversation

We just published a new demo of Plato's PBD subsystem. Much more powerful than our previous implementation.

PBD is historically difficult to generalize and make practical, but it seems that once you take it out of the desktop metaphor and apply it to relational data where queries are more explicit, it does quite well.

I suspect this could become the most prevalent way of automating app logic without coding.

🎥 Plato Demo Video

👓🎥 Pebble Graphics Trailer via Irvin Hwang

🧵 conversation

Youtube Thumbnail

Hi All

I’m almost “done” with my VR visual/spatial programming app, Pebble Graphics 🎉 (“done” because I still see a lot of things that could be improved, but there are other projects I’m excited to start so I’m shipping what I have). It’s a VR version of turtle graphics with some interactive program stepping and 3D visualizations of things like state change and execution history.

I made a trailer you can watch (and listen to 🎶) here Pebble Graphics Trailer. If you have a Quest headset and want to try it out, I set up a Beta release while I try to get it into Meta’s App Lab app store. This link meta.com/s/2Rlda8ess should work otherwise feel free to DM me the email address associated with your Oculus/Meta account.

I also have some time-stamped/annotated videos later on in this Youtube Playlist in case you want to see more.

I’m more of a lurker in this slack, but it’s a community I enjoy checking on and it’s really cool to see it grow!

Pebble Graphics is a 3D visual and interactive programming system that lets you create and explore geometric patterns in virtual reality. Using simple commands, you can control Pebbles the dog to draw lines and shapes with programming. You can also step through your programs interactively, and see unique 3D visualizations of how things change over time. Pebble Graphics is a fun and creative way to learn basic ideas in programming.

Devlog Together

📝 Version ao: saving your programs across restarts via Kartik Agaram

🧵 conversation

I released the hopefully final feature last night for my mobile-friendly REPL: file loading and saving.

Version ao: saving your programs across restarts

From here on out I only want to work on UI polish and accessibility. Let's see how long it can stay running without incompatibilities that require upgrades.

This feature was very difficult. Lua Carousel launched without the ability to save to and load from files because I struggled to juggle two constraints: Reliability. I spent a long time trying to make...

👁️‍🗨️🐦 Samuel Timbó (@io_sammt) on X via Samuel Timbó

🧵 conversation

Hi FoC, just posting here some of my latest work in Unit. unit.tools is my current take on how to search for units (live programs) online and collect your own. It is still a prototype, bear with me. unit.tools

🐦 Samuel Timbó (@io_sammt) on X: Officially announcing the second project I am building in public: https://t.co/BsxYrY7UiX

It is a marketplace to explore, collect and play with live visual programs built in Unit.

Tweet Thumbnail

📝 Version ap: a lot less jittery via Kartik Agaram

🧵 conversation

I'm starting to acquire some respect for small UX niceties like a visual 'clicked' state. It's unnerving to click 'save' and not know for sure that stuff got saved. Particularly on a small mobile screen where it's easy to fat finger things.

No new features, only fixes for bugs. From most to least embarrassing: * If you selected some text and then hit the 'clear' button the app would crash. * Dragging the mouse/finger around on top of the...

📝 Version as: major improvements to the scrollbar via Kartik Agaram

🧵 conversation

More lessons from the school of hard knocks about the value of usability in software: Version as: major improvements to the scrollbar

Taps near the top of the editor sometimes failed to move the cursor. It turns out this was only happening soon after a drag of the scrollbar. Lua Carousel's scrollbar has always felt a little jumpy. I...

🎥 Advent of Code 2023 day 1 using visual programming via Maikel van de Lisdonk

🧵 conversation

Youtube Thumbnail

Last year I used the advent of code to test the visual programming environment that I was building at that time.. and it helped me to come to the conclusion to start over.. which I did at the beginning of this year. So... the time has come to test my new environment and let advent of code help me improve and extend it. Hopefully this year I won't need to decide to start over😅. To finish the first challenge I needed to extend my vps with new node types or tweak some other stuff like be able to execute regex expressions and load external files as input to a flow. For the second part of day 1 a special node needed to be created to handle the sneaky replace string functionality that was needed. A very nice update that I made is the possibility to run parts of flow in parallel instead of sequential and use the results in the upstream nodes.

And talking about upstream nodes... since last week it's also possible to drag all upstream or downstream nodes at once when reorganizing a flow using UI elements(it can be seen in the video).

In the flow-engine I also use standalone nodes that represent global variables which can be used in other nodes.

I'll definitely not make it to the AoC leaderboard (it's not a goal anyway).. however.. I think I am getting a lot of value out of this already..even on day 1.

💬 Jimmy Miller

🧵 conversation

Been making slow, but steady progress on my editor. I can properly zoom in and out on the canvas. I can have some panes that represent sub-file things. The power usage when idle is basically non-existent (down from 100% cpu usage always). I finally feel like things are starting to come together and that I can finish up some parts and then really start focusing on actually making the flow and features fit how I code.

Hopefully soon I can start using it for a project that isn't coding itself so I am forced to add all the features I've been ignoring.

🎥 Devlog

Thinking Together

💬 Mariano Guerra

🧵 conversation

Where's the emacs people in this text centric brave new world?

Context: the most interesting stuff done on text always happened on emacs, and it makes sense to use a text centric malleable software platform to experiment by adding LLMs to everything, I haven't seen much done there.

💻 scrapscript.org via Guyren Howe

🧵 conversation

But have y’all seen this? scrapscript.org

This is my kind of thinking.

💬 Nilesh Trivedi

🧵 conversation

Thinking about a modern agent orchestration / business process modeling / workflow language. Here is how the standard BPMN example might look like:

# Tasks are enqueued jobs to specific queues. They emit events like started, success, failure, cancelled as well as custom intermediate events.

# Tasks cannot consume events. Task invoker can cancel those tasks.

# Tasks are triggerred by specific events indicated by their corresponding "when" clause.

# Process is a stateful workflow which orchestrates tasks based on events.



process pizza() do

    x = @customer.select_pizza when $start

    y = @customer.order_pizza(kind: x.kind) when x

    z = @chef.make_pizza(order: y.order) when y



    p = y.order.line_items.map do |item| # array processing

        subprocess procure(item: item) #invoke a subprocess

    end when z

    q = @clerk.pack when p.all?



    w = @delivery_boy.deliver_pizza(to: y.address) when z

    u = @customer.pay_for_pizza when w

    v = @customer.eat_pizza when u

    success $hunger_satisfied when v



    r = @customer.ask_for_pizza when (y or r[-1] + 60.minutes) and w.pending?

    s = @clerk.calm_the_customer when r

end

image.png

Present Company

💬 Mariano Guerra

🧵 conversation

hi! tinyletter (the service I use for the FoC newsletter) is closing down, to finish the last stage of going completely self hosted I plan to export the subscriber list, put it in a csv, do a for loop and use some mail api to send it. Also a form somewhere that appends to that csv. But before adopting this webscale architecture ™ I wanted to ask you

if there's any interesting idea to improve the newsletter now that I'm doing the migration .

Future of Coding Weekly 2023/11 Week 4

2023-11-26 23:26

💼 Spreadsheets & Small Software 🎠 Lua Carousel 🗺️ Embark: Dynamic documents for making plans

Two Minute Week

🎥 Wrap and unwrap expression via U03U0SCU5LH

🧵 conversation

Youtube Thumbnail

Last week I worked on Wrap / Unwrap Expression. See description under video. (no audio)

Btw. if somebody has a better verb instead of wrap.. let me know.

Our Work

💼 Spreadsheets and Small Software via Prabhanshu Gupta

🧵 conversation

I’ve been researching spreadsheets and writing one for a couple months. I wrote a bit about the what and the why, give it a read!

blog.nilenso.com/blog/2023/11/10/spreadsheets-and-small-software

I wasn’t able to cover many specifics here – writing about the work seems like a lot more work than doing the actual work 😅. There’s a lot to cover and I’m hoping to get to it slowly. Until then please shoot thoughts and questions here, I’d love to answer.

🎥 Arroost: Normalise sharing scrappy fiddles via Lu Wilson

🧵 conversation

Youtube Thumbnail

Watch my new talk!

It's about a music-making node-based language tool for feeling.

ARROOST: NORMALISE SHARING SCRAPPY FIDDLES

📝 Let's Build a Programming Language via Mike Austin

🧵 conversation

I've demoed my Kopi language and Rect-Desktop projects a few weeks ago. In my experience writing Kopi, I've always wanted to write a "How to Write a Programming Language" tutorial based on it, since the core language is simple and familiar (infix operators, assignment, anonymous functions, etc.). Here's the start of something (written in Markdown, presented using the React-Desktop Markdown app:

Let's Build a Programming Language

It's in an early draft. I like presenting ideas very incrementally, and being able to see and even interact with each small change. You can modify any of input or parser code and see the result value change.

🎠 Lua Carousel via Kartik Agaram

🧵 conversation

Lua Carousel: A lightweight programming environment for desktop and mobile devices that you can make changes to while it's running.

repo: git.sr.ht/~akkartik/carousel.love

🎥 Lua Carousel Demo

💬 Daniel Garcia

🧵 conversation

Followup on my ~_*Colorful types*_~ project. I’m trying to create a ~_*map*_~ for a codebase with different zoom levels.

I have been thinking about having 3 zoom levels:

  • Level 1: Only colors for both types & functions
  • Level 2: Colors and names for types, functions and parameters
  • Level 3: Shows the entire source file (maybe with some extra color sugar on top?)

Here are a couple of screenshots of level 1 & 2, and video of the WIP interface.

PS. Anyone have good recommendations of typescript codebases with a couple dozen source code files which I can use for testing?

Screenshot 2023-11-22 at 9.01.09 PM.png

Screenshot 2023-11-22 at 8.58.08 PM.png

🎥 Demo

Devlog Together

💬 Kartik Agaram

🧵 conversation

More progress on a lightweight programming environment that runs on Linux, Windows, Mac, Android, iOS. Also modifiable live while it runs (though not on mobile devices).

The seed design constraint here was to structurally prevent the pop-up keyboard on a touchscreen from ever blocking my typing. That led to this design of a multi-line commandline editor in the top half, fixing the non-editable output buffer in the bottom half. Independent commands/scripts then expanded in the only other direction available: left/right.

🎥 Carousel Shell

💬 Kartik Agaram

🧵 conversation

🎥 Carousel Shell Slider

🗺️ Dispatch 001:On Embark and Lude via Duncan Cragg

🧵 conversation

Hiya, I just read this new newsletter from Ink'n'Switch:

inkandswitch.com/newsletter/dispatch-001

And it says:

Solo independent researchers we know often discuss the challenge of working alone. Being part of a research group can create community, social accountability, provide feedback, and just give you someone to talk to when you’re feeling stuck or bored. This is why we started our Researchers-in-Residence program.

Which made me think "this could be something we set up in FoC!"

And then I came right here to say that, without thinking it through any further...

🎥 Creating html for nodes using gpt4 api in a visual programming system via Maikel van de Lisdonk

🧵 conversation

Youtube Thumbnail

Hi, in this weeks video I show a new node type in which a prompt can be entered which is used to create HTML via openai gpt4. It's quite powerful .. the created nodes can receive and visualize input data from another node. This is offcourse inspired by makeitreal from tldraw which uses gpt4-vision-preview. I have been playing with the prompt to get the result that I wanted, although the results are not consistent when recreating the html using the same prompt. Still, very cool that this is possible.

💬 Kartik Agaram

🧵 conversation

Achievement unlocked: I've built an app large enough[1] that it crashes my programming environment that puts all the code on a spatial surface.

The problem: I do this snazzy initial animation (see video) that takes in the whole thing before zooming back in somewhere. That animation works by drawing the whole surface to an in-memory canvas before transforming it. Turns out drawing to a canvas still uses the video card, and I don't have enough video RAM for a virtual "monitor" of this resolution.

[1] Or spread out enough. It's not really about lines of code, just how much area the code occupies.

🎥 bf codemap

Reading Together

💬 Beni Cherniavsky-Paskin

🧵 conversation

I was leafing through my father's old books when this diagram caught me off-guard.

We're so used now to having an OS with apps, that it's weird to think of OS-level transitions (login->shell), inter-apps transitions (shell->vi) and inside-app transitions (vi's command<->append modes) as similar things. 🙃

But to a user new to computers, yes these are all "modes".

IMG_20231012_130106.jpg

💬 Janne Aukia

🧵 conversation

I think that often the most difficult part of programming is debugging: humans aren't very good at "seeing" how an app operated when it failed. You get some log output that might or might not have references to the correct file locations.

I don't see any reason, in the long term, why humans would be better than machines at debugging. How to make that happen? I assume somebody is building this already. Would it help if an AI with a large context window + access to the VM could see the whole call logs/tree and see exactly what is going on? AI could learn from other users, see everything that happens in a run without debugger/console.logs, try multiple solutions in parallel, and fix issues while you sleep.

Thoughts on this?

Content

📝 Spreadsheets and Small Software - nilenso blog via Benji York

🧵 conversation

"We wanted tools to make sheds, we got tools to make skyscrapers."

🗺️ Embark — Dynamic documents for making plans via Ivan Reese

🧵 conversation

Ink & Switch just released a new essay: Embark — Dynamic documents for making plans.

Starting from a desire to "unbundle the app" in the name of malleable software, they explore using a bullet-point outliner as a substrate for dynamic properties, computations, and views. They ground the work with a specific use case — trip planning — and they hard-code a bunch of stuff that ought to be pushed into user space, granted. But it's easy to look at this, imagine how it could be expanded, and see some really compelling possibilities for a different way to approach creating and distributing software.

Congrats to Paul Sonnentag, @Alexander Obenauer, and Geoffrey Litt!

💻 Pickcode | Make cool stuff with code via Mattia Fregola

🧵 conversation

Pickcode – a visual language to teach kids to code.

🧶 There are no strings on me via Justin Blank

🧵 conversation

An essay on the challenges of image based/live systems: There are no strings on me

📝 Lua Carousel: create little programs on desktop or mobile devices via Walker Griggs

🧵 conversation

A saw a friendly face on the front page of lobsters this morning

🎥 Bootstrap yourself into conviviality by writing your own Forth via Kartik Agaram

🧵 conversation

Vimeo Thumbnail

I just found an absolutely ancient bit of advocacy for convivial tools. From 2008!

via muforth.nimblemachines.com

Jonathan Edwards Were y'all aware of this when you organized 2020.programming-conference.org/home/salon-2020?

Future of Coding Weekly 2023/11 Week 3

2023-11-20 00:59

🎙️ FoC 68 Philip Wadler: Propositions as Types 🧠 Neurosymbolic Programming 🐟 The Object Network for goldfish

Our Work

🎥 New Jersey Cards via Mariano Guerra

🧵 conversation

Youtube Thumbnail

🗂 New Jersey Cards: Worse Cards are Better

Simple textual format to keep practice notes.

📝 Capture & practice content in Markdown-ish

  • Question -> Answer & Optional Notes

🎼 Extensions to display guitar chords and music scores with ASCII-art

📟 Runs on anything that can serve static files

💻 github.com/marianoguerra/nj-cards

📝 The Object Network for goldfish via Duncan Cragg

🧵 conversation

Hiya - my latest article - "The Object Network for goldfish" - is out!

I tried to simplify the message down to the bare minimum. Let me know if that works for you! You may have to be a goldfish to understand it, mind.

An OS with no apps frees our data from the "app trap"

🎙️ FoC 68 Philip Wadler: Propositions as Types via Ivan Reese

🧵 conversation

The subject of this episode’s paper — Propositions as Types by Philip Wadler — is one of those grand ideas that makes you want to go stargazing. To stare out into space and just disassociate from your body and become one with the heavens. Everything — life, space, time, existence — all of it is a joke! A cosmic ribbing delivered by the laws of the universe or some higher power or, perhaps, higher order. Humanity waited two thousand years, from the time of the ancient Greeks through until the 1930s, for a means to answer questions of calculability, when three suddenly arrived all at once:

  • General recursive functions by Gödel in 1934, with functions of sets of natural numbers.
  • Lambda calculus by Alonzo Church in 1936, with anonymous single-variable functions.
  • Turing machines by Alan Turing in 1937, with a process for evaluating symbols on a tape.

Then it was discovered that these three models of computation were, in fact, perfectly equivalent. That any statement made in one could be made in the others. A striking coincidence, sure, but not without precedent. But then it was quietly determined (in 1934, again in 1969, and finally published in 1980) that computation itself is in a direct correspondence with logic. That every proposition in a given logic corresponds with a type in a given programming language, every proof corresponds with a program, and the simplification of the proof corresponds with the evaluation of the program.

The implications boggle the mind. How could this be so? Well, how could it be any other way? Why did it take so long to discover? What other discoveries like this are perched on the precipice of revelation?

Philip Wadler is here to walk us through this bit of history, suggest answers to some of these questions, and point us in a direction to search for more.

And we are here, dear listener, to level with you that a lot of this stuff is miserably hard to approach, presented with the symbols and language of formal logic that is so often inscrutable to outsiders. By walking you through Wadler’s paper (and the much more approachable Strange Loop talk), and tying it in with the cultural context of modern functional programming, we hope you’ll gain an appreciation for this remarkable, divine pun that sits beneath all of computation.

Devlog Together

💻 MiniIDE: live code inside a LOVE app via Kartik Agaram

🧵 conversation

I seem to have renewed my collaboration for a tablet-friendly programming environment. For the current version, my partner led and pushed for preserving LÖVE primitives. For example, the LÖVE event loop calls functions you define called love.draw , love.keypressed , etc., and it seems desirable to continue to support those for familiarity's sake. This can seem impossible if the environment is also built in LÖVE and uses those same functions for providing its infrastructure, but since Lua is a dynamic environment there are tricks to make it work reasonably nicely.

Lately I've been taking the lead on a riff of that project, and I find I'm advocating strongly to not do this. I want to define new handlers like shell.draw and shell.keypressed that programs within my environment will have to call. And I finally figured out why I feel so strongly about this:

  • LÖVE has a function to return the bounds of the device/window. You typically can draw between x coordinates 0 and some width. And this information is often used to draw UI elements near the edges and corners. So should we now override functions like line to adjust coordinates and keep them in the client area? There's a lot of surface area to cover here. Bugs will inevitably happen, and when they do our attempts to create a seamless abstraction will cause more confusion.
  • Ranting more broadly, the desire for a "seamless experience" is a disease. The provider wants to "own the customer relationship," so that the user can forget there's anything in the universe but themselves and the app. Just like a casino. I'd rather not pretend we can wish the universe away with its possibility of errors. Let's me and the user treat each other as grown-ups, and not hide irreducible complexity in our supply chains. Here are the functions I provide, here are the functions LÖVE provides. I recommend you use my stuff where possible, but you don't have to. Yes, it's confusing. Welcome.

carousel-shell-mockup.png

💬 Kartik Agaram

🧵 conversation

Last night I built a little program to help first-graders drill on addition -- and promptly found a bug while recording this 😂 (You can see me show the generated solution at the end. It's wrong!)

(Fear not, this will go through usability/correctness testing with the teacher/mother before the kids are subject to it.)

🎥 Sum Grid Demo

🎥 Creating a basic glsl shader using a pull-based flow via Maikel van de Lisdonk

🧵 conversation

Youtube Thumbnail

Hi, since I've started building visual programming systems, I have always used a push-based approach where a node triggers another node that follows it. This is much inspired by flow based programming. But since I want to build a generic visual programming system, I think that it is also important to support different ways.. basic statecharts I already support, but a pull-based system is not yet something that I had build with my system. Until now! .. so in this video you can see how I construct a flow that is used to construct a glsl fragment shader. Here the output node pulls in the data from the node's cominh before it in the flow, so working backwards through a flow.

Although it's not my goal to build a full product around this alone.. a lot better and much more extensive applications already exist for building shaders this way. But still helpful to look at my project from a different perspective, which leads to some refactoring, bug fixing, insights and inspiration.

Yesterday I was really in doubt if this was the right route for this week's time spent on my project because of the awesome demo that tldraw made with gpt4-vision api, very cool! So,I also had to play with it together with my own application and was also amazed with the possibilities! Probably my next video will have this as a topic. Anyway, for now, enjoy my short video where I construct a very simple shader which runs on the GPU via webgl.

💬 Kartik Agaram

🧵 conversation

I'm finally starting to think about scrollbars.

scrollbars

🎥 Scrollbar Demo

Thinking Together

💬 Gregor

🧵 conversation

Is there a good catalogue of programming languages? Preferably with the option of searching by feature or comparing languages on some dimensions?

📝 Life-critical side projects via Tom Lieber

🧵 conversation

Kartik Agaram It wasn’t on-topic in the thread you started a while back, my but first thought when considering building software like that is “Writing a social media app is frightening” (or more generally, “Storing user data is frightening”), as this post just reminded me: Life-critical side projects

💬 Tom Lieber

🧵 conversation

I built a Magic Inky interface at work a while back. A metadata editor that presented as a nested bulleted list of English sentences with clickable words, like:

“From [time T1] to [time T2], an [event type] happens with [property P], and it’s very [adjective].”

The event descriptions are highly multi-dimensional and resonate well with this information design, though the timestamps suffer a bit. They want to be on a timeline, but I didn’t have the budget. Despite this, the UI has saved us loads of time and people ~love~ the sentence-based configuration compared to the forty-column table of dropdowns they envisioned when I started the project.

The biggest failure was that enforcing a few global constraints was ~also~ outside my budget. Lacking those has led to data loss—never more than a few minute’s worth, but still. I felt bad. Thankfully, someone else recently picked up the project and will be correcting those omissions.

But we disagreed immediately on how to do it! I thought we should ~present~ the errors: “These events overlap!” The other person thought we should make the errors impossible: when you edit a timestamp, you implicitly edit all the others that are involved in the constraint.

I generally agree with their approach. I mean, it’s baked into the rest of the UI. When you change an event type, it changes the rest of the sentence. But if you change the type back, the sentence structure is restored and your previous values all come back. Cascading edits are more destructive than that. They force you to be careful about what you change and to be observant of unintended side-effects.

The block editor problem of representing invalid states is another way to look at it. Sometimes the most efficient path between two valid states passes through an invalid one. If you want to reorder two events, for example, a first step might be to copy the start and end times from one to the other, as part of an “a = b; b = oldA” sequence. They overlap until you’re done. To do the same without ever breaking global constraints requires user ingenuity or a more featureful editor with a “swap events” button. Requiring user ingenuity wastes a lot of time and energy and happiness over the lifetime of the UI, but observing users and adding features to address every desired editing operation takes a lot of dev time too, and it has to happen ~now~ , or else people editing this data will be blocked whenever they find an impossible edit.

Anyway, not too many answers here, but I thought it was an interesting case study, with thought-provoking ~questions~ at least!

🐦 Tweet from @mrmkrs via Scott

🧵 conversation

An idea is starting to form for me around prototype-based modeling being a good metaphor for programming effectively with LLMs. Essentially you can provide an example of a patttern/component/class/etc and have it return a version of it modified in specific ways, which can then be used as a prototype for future generations/instantiations.

A version of this idea can be seen here with tldraw where he generates the next more specific interface step off the previous one.

Another I'm kind of using this in my agent framework: generate_sublayer_agent_agent.rb where we generate new agents based off a simple agent template (and works surprisingly well).

I know Hofstatder digs into this concept in GEB and Steve Yegge calls it the Universal Design Pattern

Does this resonate with anyone here? Is anyone familiar with any other writing about prototype-based modeling/prototypal inheritance/etc for me to take this further?

Content

📝 I’m excited to see where this 3rd party screen-reader for macOS goes. via Eli Mellen

🧵 conversation

I’m excited to see where this 3rd party screen-reader for macOS goes. On windows there are 2 first-in-class options available outside of the OS, JAWS and NVDA. On macOS there is only the system provided VoiceOver.

I think VoiceOver is a pretty solid competitor to NVDA, but, it is very very very opinionated, and makes some unusual choices. I think this has a knock on effect where, since VoiceOver is the easiest screen-reader for most web devs to reach for, a lot of implementations end up being hyper-focused on supporting VoiceOver’s specific flavor of handling the accessibility tree. Having more diversity in the space, I think could hopefully mitigate this. While this isn’t directly related to the future of coding as we normally talk about it here, I think projects like this are just the sort of thing that can help to shape things for years to come.

🎥 Editing Motion Graphics Video via Motion Vectorization and Transformation via Jack Rusher

🧵 conversation

Youtube Thumbnail

Inferring SVG animations from motion graphics videos, then providing various tools to edit the inferred material

🎥 Neurosymbolic Programming - Yisong Yue via Dany

🧵 conversation

Youtube Thumbnail

This may interest you. It talks about combining programming by example (ML) and traditional means.

📝 Designing a Programming Language to Speedrun Advent of Code via Eli Mellen

🧵 conversation

“shouldn’t this have been published a few months ago?” yeah, probably. I even considered submitting it to the AoC contest. time is a real beast. The title is clickbait. I did not design and implement a programming language for the sole or even primary purpose of leaderboarding on Advent of Code. It just turned out that the programming language I was working on fit the task remarkably well. I can’t name just a single reason I started work on my language, Noulith, back in July 2022, but I think the biggest one was even more absurdly niche: I solve and write a lot of puzzlehunts, and I wanted a better programming language to use to search word lists for words satisfying unusual constraints, such as, “Find all ten-letter words that contain each of the letters A, B, and C exactly once and that have the ninth letter K.”1 I have a folder of ten-line scripts of this kind, mostly Python, and I thought there was surely a better way to do this. Not necessarily faster — there is obviously no way I could save time on net by optimizing this process. But, for example, I wanted to be able to easily share these programs such that others could run them. I had a positive experience in this with my slightly older golflang Paradoc, which I had compiled into a WASM blob and put online and, just once, experienced the convenience of sharing a short text processing program through a link. (Puzzle: what does this program do?) I also wanted to write and run these programs while booted into a different operating system, using a different computer, or just on my phone. ...

🎥 CrystalConf 2023 via Paul Tarvydas

🧵 conversation

practical Diagrams as Syntax for program development at Kagi.com

🤖

💬 Marcelle Rusu (they/them)

🧵 conversation

I don't know much about LLMs, so I'm purely asking out of ignorance.

AFAIK Open AI has a powerful LLM system in large part due to large compute power.

Is there a future where small business / people can compete with mega-corps in the LLM space, or will we be renting GPT (or similar) until end the of time?

📝 OpenAI announces leadership transition via Josh Cho

🧵 conversation

📝 Humane officially launches the AI Pin, its OpenAI-powered wearable via Daniel Garcia

🧵 conversation

Future of Coding Weekly 2023/11 Week 2

2023-11-12 23:33

📢 Algorithmic Pattern Salon 2023 🎼 Notation Must Die 🌲 The Expanding Dark Forest & Generative AI

Two Minute Week

Our Work

📢 Algorithmic Pattern Salon 2023 via Alex McLean

🧵 conversation

An online event I'm co-running - Algorithmic Pattern Salon 2023

Talk sessions over five days, exploring contemporary and heritage algorithms in weaving, braiding, music, typography, live coding, juggling, etc etc

💻 Levlo via Jarno Montonen

🧵 conversation

It's still early, but what do you all think about levlo.com? Any feedback is welcome, but I'd especially love to hear how do you understand the product based on the messaging on the site. What would you build with it?

Levlo is a textual no-code platform that allows you to create, share, and monetize expert applications without coding. Start building your app today!

📝 Personification of computer processes via Tomaz Zlender

🧵 conversation

I've published an essay Personification of computer processes where I introduce a metaphor that will allow us to program computers in a game-like (and also in "Dynamic Land"-like) environments. The website Latent Centers is a digital garden I started recently where I will continue to publish related work. The aim is to invent computing that makes us feel more alive.

I'm looking forward to hearing your thoughts!

📝 Turning the Blob inside out via Duncan Cragg

🧵 conversation

Hi everyone, my latest article on The Object Network and OnexOS is out:

📝 Turning the Blob inside out

Idiosyncratic apps come between you and your data...

It discusses "The Blob" - apps - and how we can free our data by "simply" not having those nasty apps coming between us and our precious digital stuff...

▶️ Introducing Macros: Automate Apps with Record and Replay via Michael Gummelt

🧵 conversation

We're experimenting with a novel form of "Programming by Example", similar to Excel macros: plato.io/blog/introducing-macros

I think it can scale quite well to a complete programming system with branching, looping, etc.. Thoughts?

🎥 Macro Demo

📱 Shady Phoney via Gregor

🧵 conversation

I have started experimenting with a mobile shader editor and wrote about it over on my blurgh: dflate.io/shady-phoney

You can play with it here: shd.is

And if you wanna signal boost me: mastodon, bsky & twtr

But most of all I'd be curious to read your thoughts, associations, etc. 🙂

💭 by Kartik Agaram

🧵 conversation

Now that I've started inserting coroutines into my apps (💬 #two-minute-week) to make them more debuggable, I'm starting to find and plug gaps in error recovery:

  • I have to be careful to check the results of coroutine operations, because the underlying coroutine might have thrown an error.
  • Errors in Lua include a call stack, but errors within coroutines don't return the stack by default.
  • If I create a higher-order helper to abstract away the coroutine munging just to smear a computation across frames, does that impact the quality of debug information in the call stack? (Answer: no it doesn't in Lua, but it wasn't obvious.)
  • Call stacks returned by LÖVE aren't quite as clean as plain Lua.

💭 by Kartik Agaram

🧵 conversation

I've cleaned up the code for my debug infrastructure of 💬 #two-minute-week and improved the error flow; now you get decent call stacks even if there's a coroutine in the middle somewhere.

The debug infrastructure lives on the surface. I frequently tinker with it while debugging.

driver-map.png

Thinking Together

💬 Arcade Wise

🧵 conversation

Does anyone know of any systems that let you take the output value on a repl, edit it, and then edit the code so that your edit is true?

💬 Dane Filipczak

🧵 conversation

What are some examples of successful UIs over constraint solving systems?

I'm about to do a bit of research on this topic but thought I'd start here.

Off the dome I can think of excel (numerical constraints) and rhino grasshopper (architectural / physical constraints).

I realize this is vague, but what I have in mind is a UI that allows for constraints to be defined which are then composed together and solved behind the scenes.

In particular, I'm wondering how to represent the case where there are multiple valid solutions and offer cycling through them to the user.

💬 Xavier Lambein

🧵 conversation

I'm thinking about ways to represent/interact with a (computational) graph. I could come up with three different interfaces off the top of my head: 1) names/identifiers and application, 2) combinators/stack operations, and 3) boxes and wires. I'm curious to know if y'all can think of any other?

Content

📟 django-tui via Mattia Fregola

🧵 conversation

Really interesting looking tool – though admittedly for a very niche use-case.

🎥 Notation Must Die: The Battle For How We Read Music via Mariano Guerra

🧵 conversation

Youtube Thumbnail

🐦 Grasshopper 2.0 (@CapsuleWire) / X via Mariano Guerra

🧵 conversation

Go check twitter.com/CapsuleWire (Version 2 of the Grasshopper Algorithmic Modelling plugin for Rhinoceros 3D). for some real world node-and-wire-core inspiration.

🐦 Grasshopper 2.0 (@CapsuleWire) / X: Version 2 of the Grasshopper Algorithmic Modelling plugin for Rhinoceros 3D.

go1.jpg

go2.jpg

go3.jpg

🎥 THROAT NOTES via Ivan Reese

🧵 conversation

Youtube Thumbnail

I've been looking for an excuse to share this somewhere, so it might as well go here.

It's a beautifully animated film by Felix Colgrave titled Throat Notes. While all of his recent animations are breathtaking and delightful and worth your attention (since, like Jacob Collier, Felix is just frustratingly talented), this video in particular will be of interest to the FoC community for its contributions to classic GUI design.

🤖 GitHub Next | Copilot Workspace via Nilesh Trivedi

🧵 conversation

Repo-wide code writing by AI

GitHub Next Project: How can developers overcome the high effort of getting started on complex tasks and truly collaborate with AI to make progress quickly?

🎥 The Essence & Origins of Functional Reactive Programming • Conal Elliott • YOW! 2015 via Alex McLean

🧵 conversation

Youtube Thumbnail

I enjoyed this talk by Conal Elliott on Functional Reactive Programming (FRP)

and also enjoying some previous discussion about Conal's version of FRP here

🤖

🌲 Talk: The Expanding Dark Forest and Generative AI via Lu Wilson

🧵 conversation

I keep directing people to this talk: maggieappleton.com/forest-talk

@Maggie Appleton explores it better than anyone else

An exploration of the problems and possible futures of flooding the web with generative AI content

Future of Coding Weekly 2023/11 Week 1

2023-11-05 23:09

🎧 Future of Scrappy Music ⌨️ Wordplay Beta 🎥 Demos with Squares, Disks & Loops

Two Minute Week

🎥 Debug Coroutine Demo via Kartik Agaram

🧵 conversation

I've been experimenting with ways to debug my live programs.

(Kind of a follow-up to archive.org/details/akkartik-mu-2021-05-17, if you squint.)

🎥 Debug Coroutine Demo

🎥 Projected AR by Arcade Wise

🧵 conversation

Not quite 2 minutes, but a fun little set-up for messing around with projected AR concepts!

🎥 Projected AR

🎥 Rectangle World by Kartik Agaram

🧵 conversation

Rectangle World, a little test bed for exploring easy versions of some problems, along with techniques for writing easy-to-debug programs.

🎥 Rectangle World

Our Work

⌨️ Wordplay beta via Amy Ko

🧵 conversation

Wordplay beta is live! We’d love your feedback on everything (language design, APIs, tools, editors), and your contributions, if you’re so inclined.

🎨 MightyMeld: a future kind of dev tool via Steven Schkolne

🧵 conversation

Hey everyone -- long-time lurker, first time poster. Thrilled to share the open beta launch of MightyMeld, a visual dev tool for React I've been building with some friends of mine. mightymeld.com

Just posted this blog post telling the story and why I'm excited -- mightymeld.com/blog/open-beta

Would love to hear your thoughts! I'm a former academic who's been driven into industry out of a desire to make the theoretical practical. MightyMeld is a "visual coding" that is not like any kind of "visual coding" i would've imagined if we hadn't've built this thing starting from real production code and saying "how can we make this more visual".

📝 From app trap to freedom space via Duncan Cragg

🧵 conversation

Hiya, if you're interested in:

  • End-User Programming, Declarative languages
  • Digital Gardens or Personal Knowledge Managers/Graphers
  • Decentralisation

Then you clearly need to read my latest fine work: From app trap to freedom space

TL;DR: we can break free of the "app trap" by simply building an OS without apps !

(Don't forget to subscribe so you won't miss future updates, right into your mailbox...)

🎧 arroost.com via Lu Wilson

🧵 conversation

Hello everyone I've been making a new tool called arroost. It's for making scrappy music. Please do make something in it and send it to me.

I will post some examples of its use in the replies

Devlog Together

📝 Experimenting with chatgpt as my ghost writer via Paul Tarvydas

🧵 conversation

I’m developing a cutting-edge tool that leverages ChatGPT to ghost-write prose based on my point-form outlines, particularly focusing on ‘new ideas’ that the AI wasn’t trained on. The challenge lies in preventing hallucinations and incorrect extrapolations from the outline. Early experimental results have been promising prompting me to create a dedicated workflow tool. This tool enables me to swiftly input point-form outlines, using the user-friendly Kinopio platform for brainstorming. I then paste the outline to ChatGPT, transforming it into coherent and readable prose. Join me in revolutionizing idea development and content creation with this innovative solution! [ChatGPT]

🎥 Rectangle World II via Kartik Agaram

🧵 conversation

Today's follow-up to 💬 #two-minute-week@2023-11-03 as I try to come up with more pleasing random arrangements in Rectangle World.

🎥 Poisson Disk Sampling Debug UI via Kartik Agaram

🧵 conversation

Some satisfying debug UI for Poisson Disk Sampling (sighack.com/post/poisson-disk-sampling-bridsons-algorithm; thanks Jack Rusher for pointing me at it)

Couple more videos in 🧵

🎥 Poisson Disk Sampling Debug UI

🎥 Creating new flow using a "back-loop" and placing the "back-loop" connection on a separate layer via Maikel van de Lisdonk

🧵 conversation

Youtube Thumbnail

Hi, the last month I've been focussing a lot on fixing some bugs in the way nodes are connected and improving the different path types that are used.

This small demo video (Creating new flow using a "back-loop" and placing the "back-loop" connection on a separate layer) shows creating a very small flow from scratch, the functionality of the flow is not important here.. but the thing I wanted to show is the way a "backloop" is created. The system uses a different svg path for backloops: normal nodes are connected using a bezier curve but when the output node is placed before the start node, the path changes to a "back-loop".

Another thing to notice is the layering.. the back-loop is placed on its own layer, hopefully keeping bigger flows more clear. You can toggle which layer is in front.

Thinking Together

🧑‍🎨 music thing via Arcade Wise

🧵 conversation

I've been working on learning UI design, what do y'all think of this? music thing

💬 John Flockton

🧵 conversation

Hey folks! I'm doing some research into code formatters/pretty printers, with a view to potentially building my own. Does any one have any examples of code formatters that they've found especially fast, or that they know of which have a special focus on performance?

I'm interested in learning about some of the potential techniques at play - what sort of caching and parallelization is being done, are they doing incremental parsing like tree-sitter etc..

💬 Mike Austin

🧵 conversation

Over the years, I've thought about different ways of creating an interactive tutorial about writing a simple programming language. For example, you can create a "wizard" style with next and back buttons, or you can create one single page with the code floating on the right side of the content (possibly sticky). One detail is that each example would grow in size (for the complete code), but would only focus on one sub-section. I thought about collapsing sections already covered, but being able to expand them, or just have a single button to expand all the hidden code. Has anyone had experience or have seen articles that use a "build from small to large", showing code along the way?

💬 Arcade Wise

🧵 conversation

This is a cute little section from the wordmaster manual :>

image.png

I did in fact get the 12 lines

image.png

considered harmful?

image.png

🤖

💬 Nicolay Gerold

🧵 conversation

Hey 🙂

I am looking for inspiration in building frontends with LLMs. I am looking for companies, which have LLMs (their own or wrappers around GPT) deployed in customer-facing applications (B2B and B2C) at some level of scale.

Something like Sudowrite and Jasper.

Also if you know some impressive solobuilders, feel free to name drop them 🙂

I would appreciate any link or name dropped in the thread 😉

Future of Coding Weekly 2023/10 Week 5

2023-10-30 00:51

🖼️ Drawing Images Explains Programs 🐰 Data Exploration, Visualization & Learning 💡 Is generic code just hopeless in practice?

Two Minute Week

Our Work

💬 Daniel Garcia

🧵 conversation

I’ve been working on a tool to get a high level view of an entire typescript codebase to help me understand/navigate it.

It shows all the functions and interfaces. Every interface is represented by a color, and the signature of a function is shown with these colors.

I need some help with a better algorithm to transform the name of the type into to a color. e.g. the type string -> blue, int -> green, etc.

The problem is that I’m not sure what I want the output to be, how should the color space be distributed? how should colors be clustered?

I think I can copy what code editors use for semantic highlighting , but I haven’t been able to find an implementation of it.

Does anyone have ideas on what I should search for?

Happy to explain more, if it’s not clear.

PS. Here is how a codebase currently looks. White rectangles are files, interfaces are shown on the top, and functions on the bottom

Screenshot 2023-10-28 at 10.08.57 PM.png

Devlog Together

📝 ALDs compatibility with code projection focused of concatenative code via Kartik Agaram

🧵 conversation

Some nice original research by Lukas Süss: 💬 #thinking-together@2023-10-24T22:28:03.239Z

[October 24th, 2023 3:28 PM] lukas.suess: <@U01ULCCJB7X> I spontaneously decided to project your example to an ALD mockup to get a bit of a feeling for inhowfar ALDs are compatible with your code projection focused of concatenative code. Seems pretty good.

★ One nice thing with ALDs is that library functions are threated exactly the same as argument values. They come in as semi-implicit arguments via the grey collection abstraction-line. ★ One annoying (but I think good) restriction of ALD is that functions (and definitions in let sections) can only ever have just one single value-line as their final output (except one cheats a bit as I've done here with memocurry :smiling_imp:).

💬 Kartik Agaram

🧵 conversation

Ok, I think I've tapped into a rich new vein of pointless demos.

🔗 unit.land via Samuel Timbó

🧵 conversation

The time has come for “the bot” to leave main unit.land 🥲

📝 unit.land

Local First Open Source Distribuition of the Unit Programming Environment.

📝 Samuel Timbó on X

Doesn't unit.land feel lonely without the bot?

Thinking Together

📝 Using computers more freely and safely via Kartik Agaram

🧵 conversation

Replacing authentication with visual identity

Background: I'm starting to think about building a new forum. Given my past, it won't surprise anyone that I mean to do this outside the morass of non-convivial software that is the modern web browser. My broad plan is:

  • LÖVE v12 will support https, and release candidates are already quite stable. Good enough to start building on.
  • I'll build my forum out of a server-side API in Lua and a client in LÖVE v12. (Should be easy to support Windows, Linux, BSD and Android. Mac and iOS will require some annual contortions to build LÖVE for oneself.)
  • The server side will of course be open source just like the client. In addition, all post/comment data will be published to a git repo on something like a daily basis.

The one major open question concerns authentication. How can we have stable identity? The above architecture is intended to allow anyone to host the forum (without trying to build galaxy-brain merkle trees, federated protocols or CRDTs), and I would prefer to not take a position of power as the source of everyone's hashed passwords (an intrinsically centralizing architecture).

A few months ago someone showed me this ancient essay called "attacked from within", and I find myself thinking about it often. The whole thing is worth reading, but for this thread the crucial list of bullets halfway down is:

  • Registration keeps out good posters.
  • Registration lets in bad posters.
  • Registration attracts trolls.
  • Anonymity counters vanity.

A provocative worldview that seems at least worth exploring. Keeping this in mind, I have a hazy idea that looks like this:

  • When you run the client you get to choose your handle, but it's not unique (cf. Zooko's Triangle)
  • When you run the client for the first time, it creates an RSA keypair for you.
  • When composing messages, the client signs the message with your private key (description on Wikipedia)
  • When rendering messages, the client validates the signature against your public key and shows something like an identicon of the public key.

Implications of this setup:

  • No registration
  • Your "password" (private key) never leaves your device(s).
  • When reading a thread you see a handle like spiralganglion . However, the handle is not authoritative. Next to it is an identicon that is authoritative.
  • It's easy in a thread to see if there are ever two people with the same handle but different identicons.
  • Since the client platform is starting from scratch, accessibility and internationalization will be a challenge for a long time 😕

No guarantees this is all doable. It's quite possible the cryptographic operations will be untenably slow when implemented in Lua, and a native library for them would complicate the simple install story that is LÖVE's greatest strength.

But I'm curious to get people's thoughts on this idea in principle.

💬 Matthew Linkous

🧵 conversation

Maybe more of a general coding question but how do you y’all feel about database/stores that add fields to your documents that insert?

E.g. you insert { name: 'Titanic', director: 'James Cameron' } into movies and when you fetch it you get back {_id: 1234, _col: 'movies', name: 'Titanic', director: 'James Cameron' }

Does that bug you? Don’t care?

Are there any ways to get around this so there aren’t won’t ever have collections between user defined fields and internal metadata?

💬 FreeMasen

🧵 conversation

One of the things I am curious about is how a11y relates to the future of coding. So far it doesn't seem to come up in the discussions on the podcast but I think there is something to be said about the advancement in a11y in computing over the last 25 years and a large part of this is due to a movement away from some of the more creative interface designs (ala Magic Ink). Is there a future of code that is more accessible to people with different abilities?

🧮 Lambda Diagrams via Lukas Süss

🧵 conversation

Here's the big omega combinator as annotated lambda diagram.

Plus showing how the (here non-terminating) evaluation could be fluently animated. 🤤

( John Tromps unannoteed version here: tromp.github.io/cl/diagrams.html )

Screenshot_20231025_105239.png

💡💬 Marcelle Rusu (they/them)

🧵 conversation

In the past year or 2, I got interested in OO and I find even its basic form within a mainstream language very powerful.

Yet, when I try to advocate for using polymorphism in almost any context, I get "this is too unfamiliar"/"that's not how we do things in framework X" instead advocating for switch statements or similar.

And it really gets me thinking, if we don't even understand OO after 30 years of mainstream adoption (in some form or another) and are still doing "structured programming" with lambdas & objects, is generic code just hopeless in practice? Is there an education problem? Is it just indicative of how poor standards are that few people have the privilege to do any amount of design for their systems before developing?

If so, how does "future of coding" even matter if any form of real adoption feels impossible.

💡💬 Jimmy Miller

🧵 conversation

Forking @Marcelle Rusu (they/them)’s thread onto this bit

If so, how does "future of coding" even matter if any form of real adoption feels impossible.

(Making a new thread about this because the other one has become about OO instead of this bit)

I feel this deeply. It can often feel as if things don't get adopted. That programming doesn't change for the better. I have so many thoughts on this, it is hard to summarize.

First, I do think we can get others to adopt the things we value. It is almost never an education issue, imo and instead a value question. (I am intentionally leaving aside the OO frame here). Think about the impact that Rich Hickey has had on how many people code, not just clojure people, but in the industry broadly. How did he do it? Through Simple Made Easy, a talk largely about values, not techniques. The same is true of Bret Victor's influence on the future of coding community. He communicated values that others adopted.

I've found this to be true in practice as well. Trying to convince people to change their coding style requires diligence, communicating values, and showing how code improves because of these values. Conflict often happens when people implicitly hold very different values. I'm going to bet that is the case in the original example given.

But I also want to step back and ask, what kind of adoption, by who, by how many people? I'm willing to bet a lot of people in this slack listen to some genre of music that isn't completely mainstream. Have those genres failed because of the lack of becoming mainstream? Would they be better if they became mainstream?

💬 Arcade Wise

🧵 conversation

Have y’all heard about the PLATO computer system?

💬 Gregor

🧵 conversation

I’m looking to learn more about a space, that I’m not sure exists. Does this word comob trigger associations to existing projects: spreadsheet, schema, hierarchy?

🐰🎥 "No Code" Intro to Data Rabbit for Visualization & Dashboarding (for non-Clojure peeps) via Qqwy / Marten

🧵 conversation

Youtube Thumbnail

What do people here think about the REBL (read-eval-browse-loop) and the ‘Data Rabbit’ project which evolved from it?

Both are tools originating in Clojure, but where the REBL is about mixing writing/running Clojure with having a graphical interface to drill down into the output data (e.g. a natural ‘visual programming’ evolution of a REPL),

I’d describe Data Rabbit as the opposite: A data inspection/‘dashboard creation’ tool where you can do most tasks visually, only dropping down to Clojure if you want to do really custom things (or create new types of ‘blocks’/interactions).

💬 Qqwy / Marten

🧵 conversation

And in not totally unrelated fashion, there’s PureData (FOSS) / Cycling76' Max (paid), which are reasonably successful graph-based programming languages for digital music synthesizers.

I expect that in that particular case graph-based programming is so successful because it is a direct translation of how (analog) modular synthesizers used to be patched together, flattening the learning curve for musicians.

Content

🐍 pythontutor.com via Marcelle Rusu (they/them)

🧵 conversation

pythontutor.com

Anyone play around with this? I was given this back in first-year comsci, and I think honestly there's few tools which top it.

🖼️🎥 Kaleido Demo via Joshua Horowitz

🧵 conversation

Vimeo Thumbnail

Kaleido lets a Processing programmer draw a picture to map out different parts of their program

This idea is so simple and “unsophisticated” and it looks utterly transformative. (I’ve never seen anything like it!)

🤖

☠️ Meet Nightshade, the new tool allowing artists to ‘poison’ AI models with corrupted training data via Chris Maughan

🧵 conversation

📝 Peo generative ail via Paul Tarvydas

🧵 conversation

A.I. is simply pattern matching - a summary of a talk I attended …

Contents © 2024 Mariano Guerra - Powered by Nikola