š„ This Game Did Everything. What Happened? š Self-Steering Language Models ā¦ OhmJS: A JavaScript library for building parsers, interpreters, compilers, and more
Devlog Together
š§µ conversation
I've integrated my recent š¬ #share-your-work@2025-04-05 into my template repository for building apps based on the Lua Carousel UI which supports making changes to apps on the phone (or computer). Now any new app built from this starting point will have a rudimentary system of online help for the entire stack:
- Lua Carousel
- LĆVE
- Lua programming language syntax
And there's tooling for authors to draw box-and-arrow diagrams in the environment and hyperlink boxes to code in the app.
It's all very janky, but the combination of editing on the phone, box-and-arrow diagrams and hyperlinks everywhere seems to result in a somewhat unique programming environment worth exploring further. I'm not sure what I'll do next. Probably build some simple apps and try to build experiences for understanding their source code. This is a little bit like Literate Programming, but just a touch more graphical. LP + image maps, perhaps.
š§µ conversation
I am back on the original goal of exporting my Observable notebooks to my offline-first format (lopecode), in a way that preserves editability. I started a notebook called jumpgate, that can do the conversion, and then opens a PR against Github. The first notebook I am trying to get this working with is Jumpgate itself.
I use lightning-fs + isomorphic-git to do the Github part within a browser. The prototype is working
sourcecode on Observable: observablehq.com/@tomlarkworthy/jumpgate
git PR opened by the notebook: github.com/tomlarkworthy/lopecode/pull/4
as my repo is configured as a static host as well, we can see the result of jumpgate after going through the jumpgate here: tomlarkworthy.github.io/lopecode/notebooks/@tomlarkworthy_jumpgate.html#view=S100%28%40tomlarkworthy%2Fmodule-selection%29
Currently its slow as hell as the git checkout takes a long time. lightning-fs is storing itself in indexdb so there is not need to do a full checkout everytime, we should be able to merge with what exists. I went with simplicity for now as the stateful logic gets complicated as you have to do different git commands depending on whether you have done an initial clone etc.
I am not sure how to manage the PR branch either, I keep force pushing a single branch but thats probably not correct either, I should use a fresh one each time but then you need to be careful not to fill indexdb with orphaned work. If anyone has a strong opinion on what the ideal github workflow for syncing offline files is LMK
The jumpgate does not add the extra functionality to make a notebook editable, I need to next mixin with my editor notebooks to get the thing to do what I want. Good stage though, Having notebooks open PRs is cool.
š§µ conversation
Keep getting sidetracked by making little Lua libraries. This one implements Python-style f-strings in Lua. Pretty cool to have a language that lets you go this far with its syntax. With just a little bit of work this could be extended to implement Python's template strings (PEP 750) and then we could use Lua to make all sorts of DSLs. My initial motivation was easier printf debugging, though š
.
I started working on this on an iPad with the Codea app, of all things. Was fun, but sadly I couldn't use any of the Bret Victor-inspired things they had in it since I wasn't using any of the app-specific libraries they had.
Though putting aside the library, I think at this point the most interesting thing I did is actually making it possible to use it right on my website without having to install or download anything.
š§µ conversation
If you enjoyed fooling with parsers, I would recommend looking into OhmJS. OhmJS (plus Ohm-editor) saves a lot of work when building parsers. A game changer. There is the other half, too - once you've parsed something, what do you do with the information? I've found that doing simple string-rewriting is very, very powerful, while sounding overly-restrictive on the surface. One can design and build whole new languages by transpiling them into existing languages for compilation (that's how I use my 't2t' and 'tmx' stuff). I consider the shell (/bin/bash, /bin/zsh, etc.) to be my IDE. PLs are just "little tools" that plug into the IDE. I don't have to stick to using one language. I can pick and choose. Transpiling a new language (or nano-DSL, or Diagrammatic Programming Language) into some other language fits neatly into this workflow. The fact that OhmJS is written in JS doesn't mean that you have to use JS. You can map XYZ to Lua (or whatever). I can supply a /lot/ more info, if this interests you.
Content
š¬ Walker Griggs
š§µ conversation
Meta information diet thread: What are blogs / publications that you read frequently?
š§µ conversation
This Game Did Everything. What Happened?
Dreams is a 2020 game creation system video game developed by Media Molecule for the PlayStation 4. Players can create and play user-generated content in the forms of games, audiovisual experiences and game assets, which can be shared or remixed to be used in other players' creations.
š¤
š¬ Arvind Thyagarajan
š§µ conversation
Has anyone played extensively with the swathe of "speak english into code" systems out there, from idea through to deployment to an appreciative public? (I haven't...)
I'm wondering if, at the end of the day, you still have to be somewhat of a textual code / software engineering native in order to take advantage of this particular present-future of coding? Or if it's truly democratising access to practical computation (i.e. domain specific to the domain of semi-commercial tools, apps, integrations that software engineers work on)
I feel a lot of public excitement around it that I'm not feeling -- but as someone keen on encouraging everyone to act computationally for themselves, public excitement is * the metric so I'll admit to being mildly envious š
š§µ conversation
For anyone working with LLMs (from my colleagues at the lab where Iāve been helping out the last few months):
š Self-Steering Language Models
While test-time reasoning enables language models to tackle complex tasks, searching or planning in natural language can be slow, costly, and error-prone. But even when LMs struggle to emulate the precise reasoning steps needed to solve a problem, they often excel at describing its abstract structure--both how to verify solutions and how to search for them. This paper introduces DisCIPL, a method for "self-steering" LMs where a Planner model generates a task-specific inference program that is executed by a population of Follower models. Our approach equips LMs with the ability to write recursive search procedures that guide LM inference, enabling new forms of verifiable and efficient reasoning. When instantiated with a small Follower (e.g., Llama-3.2-1B), DisCIPL matches (and sometimes outperforms) much larger models, including GPT-4o and o1, on challenging constrained generation tasks. In decoupling planning from execution, our work opens up a design space of highly-parallelized Monte Carlo inference strategies that outperform standard best-of-N sampling, require no finetuning, and can be implemented automatically by existing LMs.
š¬ Ezhik
š§µ conversation
I wanted to learn how the CodeMirror editor works, so I asked GitHub Copilot's agent mode to build a little app that uses it for me. We had a back-and-forth where I pointed out the bugs I've seen in the UI and then it fixed it. But all this took place without me having to look at the actual code, so I don't really feel like I learned anything from this experience. That makes me wonder - do people here use these tools for learning, and if so, how?
šØš½āš» By š @marianoguerra@hachyderm.io š¦ @warianoguerra
š¬ Not a member yet? Check the Future of Coding Community
āļø Not subscribed yet? Subscribe to the Newsletter / Archive / RSS
šļø Prefer podcasts? check the Future of Coding Podcast
