Hey folks! I've been working on a language for quickly sketching out app ideas/user flows, inspired by the concept of a "software breadboard" from Basecamp's Shape Up methodology (https://basecamp.com/shapeup/1.3-chapter-04#breadboarding): it's definitely not ready for prime time yet, but I think it's got the bones of a decently expressive rapid prototyping language. Feel free to play around with the demo at https://breadboard.redefine.software. Source code is on GitHub: http://github.com/redefinesoftware/breadboarder. Curious to hear your feedback!

Hi all! I’ve been diving into CRDT tech lately to build local-first collaborative apps. So far I had a great experience with Yjs - but I found the API a bit cumbersome. I’ve been working a new open source library to make it really easy to work with state that’s shared across multiple users and that syncs automatically. It supports React, Vue, Svelte, or plain javascript. By using Javascript Proxies, the API looks just like a regular app, e.g.:

store.todos.push( { completed: true, title: "write code" } );

- and the Reactive Programming model makes it effortless to listen to changes. Anway, I just put it live on https://syncedstore.org/ - would really welcome your feedback! PS: it’s also on HN (see “show” page), comments / votes there are always appreciated to help a fellow FoCer ;)

👋 We are discussing the future of analytics engineering and notebooks — Coalesce @ 5:25 EST today!

📓 Day 6 of Advent of Future of Code: Reactive Codebooks with TypeCell Check instructions here: https://buttondown.email/reviewjam/archive/advent-of-foc-day-6-reactive-codebooks-with/ 🧵 Conversation about the task as comments to this message!

Any devs interested in tinkering on a tool to export social graph/network data from walled gardens like LinkedIn/Facebook/Discord, and build some lo-fi chat/comms on top? I've been hacking on this starting with LinkedIn. If you enable authentication with LinkedIn's 3-legged flow (https://docs.microsoft.com/en-us/linkedin/shared/authentication/authorization-code-flow?tabs=HTTPS), then you can use the Connections API with Field Request to return the connection names and unique IDs/urns (https://docs.microsoft.com/en-us/linkedin/shared/integrations/people/connections-api) for all of your connections. With that, you have a first-connections social graph. And then, just need a way to send message blobs to those folks! Here's a repo where I've been working on it: https://github.com/sbutler-gh/earthkind ^ At the moment, it's stuck because the LinkedIn 3-legged auth isn't working — not sure exactly what the problem is, whether CORS or with the redirect URIs. I added documentation in the

index.svelte

file to describe more there. If it is CORS errors, I'm not sure if that's bypassable locally, so I also spun up a deployed instance at https://earthkind.pages.dev/. That gives some redirect errors when trying to authenticate which might provide more information. I've been reflecting on this for awhile, think it could be really useful! For example, do you ever have an in-depth DM chat with a friend where you wish other people could check out the discussion/thoughts coming out? By building something that's described here, we could even give people an option to have chats that are publically indexable and discoverable — the equivalent of chatting in public, so others can overhear and join the conversation. Just one of the possibilities!

Short demo of the new Filter Card, useful to build dynamic filters based on inputs to create interactive visualizations and dashboards

Hi all! New here, I wanted to share something I made over the weekend that I thought some people here might find interesting/have thoughts on. It's a self-hosting web code editor that stores and edits "files" in the browser's IndexedDB and uses a service worker to serve them as if there was an actual backend. You can try it out here (only works in Chromium-based browsers because it uses ES modules in the worker): https://reflection-editor.netlify.app/ Source code is also available at https://github.com/Merlin04/reflection.

I wrote a tutorial for

jp

my bash-based json processor. https://github.com/dnmfarrell/jp#tutorial I'm trying to make it easy for newcomers to learn something useful and accomplish something right away (even if the Venn diagram of users with bash who need to validate/transform json and don't already use jq is small). I'd appreciate any feedback anyone has. Thanks!

Hello everyone and happy new year! I am the author of the Mech language, which I first presented at Live 2019: http://docs.mech-lang.org/#/live2019.mec Today I'm posting a follow-up blog post that covers Mech's progress over the last 2 years. Once the pandemic hit I kind of went silent, but my students and I still managed to get a lot of work done. I hope you'll give it a read! http://mech-lang.org/post/2022-01-01-happy-new-year/

Future of Coding • Episode 54 Ella Hoeppner • Vlojure I was immediately interested in Vlojure because of the visual style on display — source code represented as nested circles; an earthy brown instead of the usual dark/light theme. But as the progressed, Ella showed off a scattering of little ideas that each seemed strikingly clever and obvious in hindsight. You'd drag one of the circle "forms" to the bottom right to evaluate it, or to the bottom left to delete it. The sides of the screen are flanked by "formbars" that hold, well, whatever you want. You can reconfigure these formbars to your exact liking. Everything is manipulated with drag. The interface exudes a sense that it was designed with wholly different goals and tastes than what we usually see in visual programming projects — perfect subject matter for our show. • https://futureofcoding.org/episodes/054

🚀 HTML Is/As a Programming Language: An extension to HTML to end the eternal discussion 📚 Language Overview: https://github.com/marianoguerra/hiapl 🧑‍💻 Demo: https://marianoguerra.github.io/hiapl/

On my journey learning about CRDTs and building local-first software, I just published a new open source library; Matrix-CRDT. Matrix-CRDT connects Yjs with Matrix.org. Basically, you can connect your client-side data store to Matrix, and instead of chat messages, it sends an event stream of data model updates (CRDT updates) to Matrix. It’s now on the frontpage of HN, so get it while it’s hot 😉 Feedback welcome!

FoC Search now rewrites internal slack message links into links that point to a search that will show that message, examples (click on message link contained in the messages linked below 🐢): Message that contains link to a top level message: http://search.futureofcoding.org/history/?fromDate=2022-01-04&toDate=2022-01-06&channel=thinking-together&filter=#2022-01-05T16:20:50.368Z Message that contains link to a reply: http://search.futureofcoding.org/history/?fromDate=2021-10-18&toDate=2021-10-19&channel=share-your-work&filter=#2021-10-21T05:04:29.000Z Also now dates on messages are links that take you to a search highlighting that message with 7 days of context (7 days before and 7 days after)

10 years of accumulated rants against division of labor in software: http://akkartik.name/post/division-of-labor

Hello everyone! After a year of work, I am finally presenting the result of my Master's thesis!🎉🎓 I developed and studied a live programming environment that can provide meaningful information about the runtime behaviour of a program in practically every edit state, while retaining the intuitive and flexible interface of text editors. To provide meaningful runtime behaviour information in edit states containing incomplete programs with syntax, type or logic errors, the programming environment has to isolate errors and continue functioning for unaffected parts of the program. I call this error tolerance. Tolerance of syntax errors is realized with an integrated structure editor that incorporates a notion of incompleteness I call construction sites. Essentially, these are abstract syntax tree nodes that can contain arbitrary characters and other AST nodes. Evaluation of the program continues "around errors" instead of aborting with an exception or resulting in some "undefined" value. Because the results this produces are much more informative than an exception or undefined value, they can help the programmer find the sources of issues and resolve them much better. Because the programming environment is often evaluating unfinished code, evaluation diverges much more often. The programming environment handles this smoothly by only evaluating parts of the runtime information that are displayed and providing a mode of evaluation where the number of reductions is limited by a configurable number. This enables partial results in cases of non-termination. You can try out the editor for yourself at https://cdfa.github.io/frugel/ 👀 or by downloading a much better performing native executable from GitHub. I also created a demo video 📺 (WebArchive version (still uploading), Google Drive version) and attached a draft version of the thesis. I hope to follow up this week with a version that fixes some bugs. This Wednesday, I will be giving an online presentation about it. If you are interested in attending, I can PM you a link to watch it. Please let me know what you think!

I wanted to share one of our designers' projects built with Noodl. We've recently created a Mapbox integration, so this is a bit of an in-house experiment.

Video demo of Blawx v1 early stage proof of concept user-friendly Rules as Code tool. Declarative logic, natural language explanations, hypothetical reasoning, zero-click deploy to API, block-based controlled natural language programming environment, live code generation. All feedback very welcome. ~7m.

Hi FoC, We just released version Alpha 1.8.0 of CRANQ (cranq.io)! For those that don't know, CRANQ is - despite what the website says - a general-purpose "low-coding" IDE and code repository. It compiles to JavaScript (npm packages), and is fully extensible from within. This release is still far from our original vision - lacking in instrumentation, types, search, and general UX - but is usable enough to prototype APIs and integrations. Quick download links: • Linux (deb): https://release.cranq.io/cranq_1.8.0_amd64.deb • Linux (rpm): https://release.cranq.io/Cranq-1.8.0-1.x86_64.rpm • MacOs: https://release.cranq.io/Cranq-1.8.0-x64.dmg • Windows: https://release.cranq.io/Cranq-1.8.0_Setup.exe Thoughts, feedback welcome. We're also looking for case studies - projects that we help you build in CRANQ. DM me if you'd like to participate in our alpha programme.

I just saw a post about unit which is a really beautiful tool, and wanted to share my own work in functional graphical programming. The video below is the prototype demo from 2016 when I was starting my VR programming company https://primitive.io In this original version of our VR code visualization tool, the focus was on functional graphical building blocks of a simple RSA encryption algorithm written in Lisp. You can see function stacks in the animated runtime. The version that then became Primitive changed to focus on visualizing file system structure and class/method parsing. I would love to get back to function body parsing at some point again. Please let me know your thoughts:

Blog post announcing the revised version of Blawx. Early stage proof of concept that demonstrates natural language explanations, multiple models, hypothetical reasoning, etc. It's very rough around the edges, but feedback welcome at this early stage.

Hey folks 👋 , I’m kicking off a new Papers We Love chapter focused on Computer Science Education in particular. If you haven’t encountered Papers We Love, it’s kinda a book club for academic CS papers. This chapter will be focused on papers about learning and teaching computer science. Sharing here since I know there’s a lot of interest in the process of learning programming and how our language design and choices influence it. If you have a paper about CS education that you love, or would like to present, we’d love to hear your suggestions! You can submit them via our GitHub Discussions board. Would love to welcome y’all to present! We are still ramping up, but are targeting the last Thursday of each month for live presentations, with paper discussions continuing async via the discussion board in between.

More adventures in sandboxing[1][2] I've been working on a Zettelkasten app: https://archive.org/details/akkartik-teliva-2022-02-10 (video; 4 minutes) One interesting insight here was that putting raw file operations directly in

main

makes the app easy to audit. You can inspect just that one function and give just it permissions to perform file operations on your computer, while denying them to the rest of the app including callees of

main

. Anyways, I'd love to hear thoughts on this. I don't have experience with note-taking apps, and my UX skills suck. Let me know if you have suggestions, feature ideas, or if you'd like a private copy tailored for yourself. Situated software and all that. Main project page: https://github.com/akkartik/teliva [1] https://futureofcoding.slack.com/archives/C0120A3L30R/p1640501578098600 [2] https://futureofcoding.slack.com/archives/CCL5VVBAN/p1644198434431509

I’m excited, and a tad nervous - next Wednesday will be my first time presenting what I’ve been chewing on this year! https://twitter.com/jessmartin/status/1494048926114144268 Along with some fine folks who need no introduction: • Super jazzed to hear Alexander Obenauer give an update on his explorations of personal computing. The Potential Merits of an Itemized OS was one of my favorite pieces of writing this year. • Equally jazzed to hear @Geoffrey Litt give a rundown of his experiments with https://twemex.app, a browser plugin I use daily that makes Twitter 10x more useful IMO. Hope some of y’all can join in for the discussion afterwards; last month was my first time at one of @Jess Martin’s very nicely run Tools for Thought Rocks events, and it was a fun and thought-provoking conversation. PS: if you want a preview and are willing to give some feedback, dm me and I’d welcome some sharpening ahead of time! The clickbait tl;dr: “Why the Elm Architecture is Doomed: Or, How I Learned to Stop Worrying and Love Mutable State.” Tongue out-of-cheek, I’ll be talking about what I think we can (re)learn from the hardware world, especially around modeling, simulation, feedback control, and dynamical systems.

I would like to share with you Sturdy - a new, real-time version control platform, specifically made for work. Pull requests were designed for an open source workflow, and I think tooling can be way better in a team setting (eg. folks that do standup, planning together etc). The core ideas of Sturdy are: 1. High-level operations around developer intent 2. Early feedback (like pair-programming) which is also given asynchronously (like pull request reviews) 3. Compatible with existing tooling On the website - https://getsturdy.com/ there are some short clips of how it works. It's pretty easy to try out, I would love to hear what you folks think. Sturdy is itself open source - https://github.com/sturdy-dev/sturdy (stars welcome 🙂 ). Cheers!

I added

ORDER BY

and

LIMIT

to the Firestore query parser and I decided to create a playground for it: - Run queries - Load examples - See intermediate representations https://instadeq.github.io/firestore-query-parser-js/playground.html

I'm starting a series of blog posts covering the "History of No-code", the idea is to bring together this new interest in "Non Fregean Programming" closer to its history and theory. (the opposite of fregean according to Pygmalion is analogical, which I find to be an overloaded term to use) The first post is about Pygmalion (1975), the next one will be on an older but non-visual one. Trying to find where the limit of No-code lies 🙂 https://instadeq.com/blog/posts/no-code-history-pygmalion-1975/

I'm running a conference with a lot of FoC adjacent talks: https://www.hytradboi.com/ Featuring talks by many of the folks here: @tonsky @Mary Rose Cook @Dustin Getz @Tom Larkworthy @Pete Vilter @Corey @J. Ryan Stinnett @Geoffrey Litt

- video demo of v1.1.0-alpha of Blawx, released yesterday. Blockly-based easy-to-use visual programming environment for declarative logic knowledge representations of legislation. Any and all feedback welcome.

Made a little demo showing what it could look like to run code from a screenshot (these are just stupid simple bash scripts): https://twitter.com/nickarner/status/1501250398266351618?s=20&t=Aziomv_NC7k8ONxAtFU-YA Imagining a scenario where something like this could be used to automatically set-up dependencies / configure a dev environment / etc

https://github.com/taowen/define-function quick.js based eval sandbox, works in any WebAssembly environment