Tiny demo from some weekend hacking to bring the computer out of its box by mapping macOS spaces to physical spaces in my room https://twitter.com/tobyshooters/status/1529153009032253440?s=21&t=xULGxPhOKg3n6vR5UkVdJg

It's a big Papers We Love: Education edition tomorrow! We’re being joined by Jane Waite, researcher at the Raspberry Pi foundation, to talk about her report (co-authored with Sue Sentence) that summarises the research around programming pedagogy, drawing on 170 papers. All the info here: https://github.com/papers-we-love/edu/discussions/5

Hi everyone! Sharing a project I just launched that may be of interest to some of you! makeabetter.computer—A (tiny) microgrants for people working and thinking about the future of computing! I wrote a small twitter thread about it.

I’ve released a widget library for the visual programming editor of Desk. It's also generic and extensible widget for any purpose. You can create node-based or analog synthesizer-like UI with simple API. https://github.com/ryo33/egui_cable

Hey folks, I wanna show you something new we have been working on - an AI code review bot 🤖. Most pull requests (about 2/3) get merged without corrections, and the idea is to have the bot detect and approve them. This was born out frustration constantly waiting for 'code review' for small and safe code contribution, especially since I believe in "ship small & often. Also it allows you to focus on the trickier changes instead. 👉 Here's how it works: anybody can do a 'historical' test on any repository here - https://codeball.ai/ to test out the accuracy. To do reviews on new pull requests, it's setup as a GitHub action. I'd love to hear what you smart people think! Happy to also share more about the model too (basically it's a neural net, the inputs include features about the code, the author and author experience with the code changed, trained on over 1M code contributions).

I have created new demo video about Lisperanto project featuring Records

This isn’t super “futuristic” but it is work that I did in my spare time that I’m proud of and I think points in a general future direction. I even end the tweet thread with a meta note about the future. I spent my spare time building a visualizer for the new ruby JIT named YJIT. You can check the thread for details, but I did this primarily as a learning experience and it was a great one. I think all code bases deserve a visualization. But today those are hard, hence my meta note. Here I’ll be more direct on the meta point. I think visual programming is awesome. But we can’t leave all the nice things to new languages or wall gardens like smalltalk. We need environments that let us visualize the workings of existing codebases. I don’t think a one size fits all visualization is ever the answer. We need to be able to build visualizations at a higher level of abstraction for our codebases. We need to be able to see the entities of our codebases and how they relate. We need to be able to keep past values of our running programs around. We need an environment that can help us do this regardless of which language we are in. In every size-able codebase I work in I make my own bespoke visualizer. But doing that is tedious and relies on extensive experience building frontends. Does it need to be that way? I think not. https://twitter.com/jimmyhmiller/status/1531638254264541185

Another guest post on the blog from my friend Anton Troynikov; this time on Remixable Software: https://nickarner.com/notes/remixable-software-guest-post-may-31-2022/

(5m) Early-stage demo of the new auto-chatbot feature I'm working on in Blawx. Interested to know whether it's a compelling motivation for "rules as code", and why or why not.

I’ve been working on this canvas tool for thinking with video for nearly a year. It’s built around the premise that videotext (time-aligned transcripts for videos) can serve as an intermediary between the analytic potential of text and the intimacy of orality. Excited to get it out of beta and in front of more users! https://twitter.com/tobyshooters/status/1532108991114924036?s=20&t=Xjn71ln3-xfSOdA-rwqAZA

I've been building an editor for plain text where you can also seamlessly insert line drawings. http://akkartik.name/lines.html The link doesn't get into it because I don't expect people coming to the product for the first time to care, but I've paid at least as much attention to making it hackable as usable. Easy to build, uses a platform that is also easy to build, lots of tests in the Mu style if you look inside the source.

Future of Coding • Episode 56 Doug Engelbart • Augmenting Human Intellect I mean, what is there to say. This is a bit like Mt. Everest. Engelbart is one of the most central figures in our community. This is one of his most important works, arguably more important than the Mother of All Demos. It's also... really... well... it filled me with feelings. If you want to hear about those feelings, here's two hours of audio where @Jimmy Miller and I grapple with them. I think this might be my favourite episode of the show yet. Here is a URL. There's nothing strange about URLs. https://futureofcoding.org/episodes/056

Wrote a short thing on my frustration at the labelling of any arbitrary product or service as an “Operating System for X” https://nickarner.com/notes/not-everything-is-an-os-june-6-2022/

I am live streaming building a IoT Smart Farm sponsored by https://www.agropatterns.com/ in 1 hours time https://www.twitch.tv/tomlarkworthy using multiplayer coding in the following notebook https://observablehq.com/@tomlarkworthy/twitch-2022-06-07 (it will be a series part 1 will be mainly about setup and data storage)

Here is a new video with the progress of my code explorer project. It only works with js files, but it's using

tree-sitter

for parsing, so it just needs adding other grammars to add support for other languages. If anyone has an interesting gist of functional code with many small functions that will be a good example code to explore, please share it with me 🙏

I made a url-based game where you take care of emojis that live inside your url bar: https://linkians.com. It's like Sims but it's a 1 dimensional world of emojis. The game state is entirely contained in the url path so that you can at any point copy the url and save/share it, or edit it however you want to start the game from a different state. For example you could start from any of these links: • https://linkians.com/🌴_😘😀__ • https://linkians.com/_🌴🧘🌴___😀_ • https://linkians.com/🌴_🕺🔊😅__ I know this isn't pushing coding forward necessarily, but is an experiment in terms of user hackable game state and storage systems. I wanted to make a game where the game "server" has no logic and stores no state. The user can completely control the state of the game and save/edit/share it with just a human readable link. It's a work in progress, I'd love feedback! (cc @Mark Christian)

https://twitch.tv/gamesdesignart Live from 6:15 PM games design and art degree show opening evening Haven't been able to intro myself yet but I run a progressive games design course in the UK with our show opening tonight at Winchester School of Art

Hi, those of you who follow me on Twitter have probably already seen this, but recently a friend encouraged me to share it here as well. For some time, I've been working on a graphical Scheme programming environment that I have called GRASP (which stands for "GRAphical Scheme Programming"). Currently I am doing fourth prototype (which I hope will become the production version), which - as I imagine - should work in text terminals as well as on graphical displays. But by far, the third prototype was the most mature, and (at least in my opinion) the most pleasant to use. GRASP is intended to work natively on mobile devices, and the third prototype was written in Java entirely on my phone (using the Termux environment). I have recorded a few videos showing the touch interface to GRASP. For example, here's a demo which shows the definition of factorial and here's another one, which shows how a screen can be splitted: I am mentioning this, because I think that - even though I do not develop it anymore - it wasn't actually that far from being useful software: it lets the user open files (supporting the basic part of the s-expression syntax) and save them as well, so with some patience it could be used for doing some "real" work. The main problem is that newly-created files are saved in the app's "internal storage", whereas the file browser can only open files from "external storage". This shouldn't be hard to solve, however, so if anyone's interested, the code is available at https://github.com/panicz/grasp-android/tree/master/stages The `stage5' directory contains a plain s-expression editor, and the `stage6' directory additionally includes the Kawa Scheme implementation and lets one evaluate the Scheme expressions (the drawback is that it takes significantly longer to build). Some Scheme features that are missing from both the parser and representation (and would be hard to add to this prototype) include: - dotted lists - strings - comments - vectors - quote/quasiquote/unquote etc. abbreviations (the abbreviations accidentally work in Kawa when they're used on symbols, but if the abbreviating characters were placed in front of opening parentheses, they'd be treated just as regular symbols) Also, there are some bugs related to positioning, but I wasn't really trying to fix them, given that I started a new prototype from scratch. The currently developed prototype can be found in the

retreat/GRASP

directory in the same repository. It is written in Kawa Scheme (but it requires an unreleased version of Kawa built from the tip of their repository), and it currently only works in text terminals. And I think that "works" is a slight exaggeration here. It is capable of parsing more Scheme syntax (including three types of comments, dotted lists and strings - though vectors and quote abbreviations still aren't supported). It also features a cursor that is supposed to work roughly as in the regular text editors. It uses a more classical representation of s-expressions, namely - good old cons-cells. (The information about whitespace and comments is stored in weak-key hash tables) In order to run this prototype, it's sufficient to run "./editor" (provided that a proper build of Kawa is available somewhere in the path - and that also requires a JVM). However, the "taste" of the editor can be obtained from the following "unit-test suite" (which doesn't yet pass, but should give a rough idea of the experience that I'm aiming at) https://github.com/panicz/grasp-android/blob/master/stages/retreat/GRASP/src/test-writing-map.scm Unfortunately none of those prototypes conveys the full spectrum of ideas that I'm trying to pursue. One important aspect was captured by the first prototype, the one that I wrote in Racket: The demo shows (around seconds 35-45) a custom representation for graphs that can be used as an alternative to s-expressions. Of course the key idea isn't to represent graphs, but to be able to provide custom visual representations/interactions of any data structure. (This idea has recently been pursued by Leif Andersen, who calls it "visual interactive syntax", and implemented that as an extension to the dr Racket IDE as well as a browser based IDE for Clojure available at https://visr.pl/) In many ways, GRASP also seems similar to Boxer (that I learned about relatively recently), but to be honest, my greatest source of inspiration so far has been Emacs and the experience it provides for working with various Lisps, as well as its self-introspection capabilities.

Handmade Network is holding a weeklong jam in August: https://handmade.network/jam Here's my proposal: https://github.com/HandmadeNetwork/wishlist/discussions/14

Hej. Glad to have found this community I think it's what I have been looking for for a while. I'm super interested in end user programming. (That seems like a good future of coding topic, or does anyone know a specific "end user programming" community) Over the last year I have built my own language and structured editor. Pushing the idea of how much can a compiler tell you about your program. The idea is to have a really small AST, there are about 10 different nodes. Because it so small writing new static analysis tools should be easy, it's also really easy to target new environments. i.e. it took me about an hour to write a to Javascript. To keep it small I've made some unusual choices, for one the language contains type provider but not numbers. I keep a dev log of 3-8 minute long videos on various topics. https://petersaxton.uk/log/ Beyond that it's not really usable to anyone else (I haven't documented the keys for the editor so the only way to start is by referring to the source) That might change at somepoint, but I don't know when.

A little notebook that is also a database - https://www.scattered-thoughts.net/log/0025#preimp

I've updated webcode so that owners of endpoints can configure "public livecoding", which allows any logged in user to grab the public traffic to that endpoint (well, each logged in user gets their own fingerprinted endpoint, so traffix is not mixed between users). So finally I can write a public demo of livecoding. This article is maybe too long but its how to implement a webserver including: serving and responding to web forms, serving a dynamic image (e.g. dashboard), and streamed responses. webcode offers a fairly low level HTTP interface so achieving most of those things requires a fair amount of HTTP knowledge, hence I thought I would just write it up. https://observablehq.com/@endpointservices/livecode

Hello all, I have been building a visual editor for compound graph datasets: https://grapheralpha.netlify.app/ Compound graphs are those where nodes have two kinds of connections: Adjacency and Inclusion. I.e. A node can be a child of another node - in addition to having other kind of edges. Cytoscape JS is great at visualizing such graphs, but I couldn’t find a visual editor for these kind of datasets. This is NOT a diagram-editor for which there are plenty of choices (like TLDraw or Excalidraw). This is built with SVG and Svelte and works completely in the browser. I will be open-sourcing it in the coming weeks.

Hey all, we’ve made some more progress on Wasp lately and added a few bigger features (e.g. running async jobs/workers - https://wasp-lang.dev/blog/2022/06/15/jobs-feature-announcement) so wanted to share with the community here 🙂. Since we’re moving towards Beta and plan to release in a couple of months, we’d also appreciate your feedback - we’re running a small Alpha Testing Program (takes ~45mins + we tried to make it fun :D) and would be thrilled to get your thoughts and ideas on how we can make Wasp better 🙂. You can find more details and apply here: https://wasp-lang.notion.site/Wasp-Alpha-Testing-Program-Admissions-dca25649d63849cb8dfc55881e4f6f82 Thanks a lot and honored to be a part of the community!

I'm building a new prototype, working title: GLUI It's an attempt to enable creating complex configurations and scripts while avoiding the problems and limitations of configuration languages, scripting languages and UIs Here's the introduction video: If you find it too long you may want to use the Chapters feature to jump to sections that interest you. The introduction and motivation may be useful to get an overview. For a quick take on the powerful aspects of the prototype you may want to jump to 14:34 where I reuse a connection config in 3 places by linking to it and the derive a new configuration from it by using the derive feature. You want to try it? here it is, just remember it's the first version: https://instadeq.com/experiments/glui/v1/ Please let me know what you think, if you would like to know more, contact me and we can get into the details and/or long term objectives.

I showed lines.love here a few weeks ago, and I've been mostly fixing bugs since. It might be converging to a fixed point now; no more features, bugs slowing to a trickle, most changes containing a 1-line fix and a dozen lines for a test. Then my hope is that it will continue to work reliably for a while without needing any updates (assuming future versions of https://love2d.org cooperate). To freeze things I need to provide escape hatches. When people ask for new features, provide them either in forks (example) or as separate applications entirely. That way the lines.love codebase stays approachable/hackable/habitable, particularly for people who don't need the additional features. Here's an example of a separate application: an exporter to markdown+SVG: https://codeberg.org/akkartik/lines2md. You can see it in action in this video. There's minimal UI here. I export files by dragging them on the exporter window, and it emits new files in the folder window that I can then open in any markdown application (that can render SVG).

In an editor that the main building block is a function, is straight-forward to open a stacktrace. Do you know/use any plugins that can do something similar in other editors?

A simple concept to manage lists, where users can build up a knowledge base (stored in Local Storage), and by importing/exporting JSON files can keep that knowledge base in sync with each other, the goal here is 'what is the most simple yet functional way of managing lists of information' https://listmanager.dev/ Would love anyone to riff on this idea, or ideas about how to add programmability into it, while maintaining the minimalist approach.

If you are interested in testing a prototype tutorial for me, for Blawx, check out dev.blawx.com. create an account, click new project, wills tutorial, open the project, click code editor, and click Tutorial. My 11-year-old did it in 30 minutes. All feedback appreciated. It is user-friendly legal knowledge representation in goal-directed constraint answer set programming. But that sounds scary, the vibe is more like "Scratch for Laws."