Lightnews — Scholar-powered news

Mariano Guerra @marianoguerra.org · 17h

I wanted to share a sketch[1] of an idea to someone, without thinking I sketched it in my remarkable, took a picture with the phone and shared it as an attachment in a chat.

A reflection on the state of "tools for thought" in desktop/laptop land?

[1] a "boxes, words and arrows" diagram

4

Mariano Guerra @marianoguerra.org · 18h

"See?"
(Kauffman, Systems 2)

2

Mariano Guerra @marianoguerra.org · 1d

- Mariano, did you add macros to vibecard?

- Marge, I'm not gonna lie to you

1

Reposted by Mariano Guerra

Tomas Petricek @tomasp.net · 2d

I'm teaching 𝗪𝗿𝗶𝘁𝗲 𝘆𝗼𝘂𝗿 𝗼𝘄𝗻 𝘁𝗶𝗻𝘆 𝗽𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴 𝘀𝘆𝘀𝘁𝗲𝗺(𝘀)! again. I'll be posting the videos & tasks on YouTube too.

In the first lecture, I explain what's a tiny system, why write one and show plenty of demos!

🎞️ Playlist: www.youtube.com/playlist?lis...
👉 More info: d3s.mff.cuni.cz/teaching/npr...

Write your own tiny programming system(s)! - YouTube

The goal of this course is to teach how fundamental programming language techniques, algorithms and systems work by writing their miniature versions. The cou...

www.youtube.com

14 40

Reposted by Mariano Guerra

Szymon Kaliski @szymonkaliski.com · 2d

⬛⬛⬛⬛

4 2 12

Mariano Guerra @marianoguerra.org · 2d

We were promised AGI, instead we got a no-code workflow builder with global variables, if/else, while and js expressions.

3 1 8

Mariano Guerra @marianoguerra.org · 4d

📰 Future of Coding Weekly

💡 Computational Substrate for Document-Oriented End-User Programming

🎥 All the videos from LIVE 2025

📝 What We’ve Built Is a Computational Language

🔗 newsletter.futureofcoding.org/posts/future...

4

Reposted by Mariano Guerra

Patrick Dubroy @dubroy.com · 4d

TIL: WebAssembly library initialization patterns
→https://github.com/pdubroy/til/blob/main/js/2025-10-05-WebAssembly-library-initialization-patterns.md

$I was curious how people are shipping WebAssembly as part of JavaScript libraries. There are two main questions: How to bundle or fetch the .wasm payload, which may be relatively large. How to deal with module instantiation, which is typically async. In this post, I'm only concerned with #2 — how to deal with module instantion. Async factory function as default export Emscripten's modularized output option produces a module whose default export is an async factory function: import MyLib from './my-lib.js'; const myLib = await MyLib(); Required async init Another pattern I've seen is to export an async initialization function, which you're required to call before using the library. E.g., in esbuild-wasm: import * as esbuild from 'esbuild-wasm' await esbuild.initialize({ wasmURL: './node_modules/esbuild-wasm/esbuild.wasm', }) And in the Automerge unbundled example: import * as AutomergeRepo from "https://esm.sh/@automerge/react@2.2.0/slim?bundle-deps"; await AutomergeRepo.initializeWasm( fetch("https://esm.sh/@automerge/automerge/dist/automerge.wasm") ); wasm-bindgen without a bundler: import init, { add } from './my_lib.js'; await init(); Hidden async init PGlite has a nice variation on the "required async init" pattern. You can synchronously initialize a PGlite instance: import { PGlite } from '@electric-sql/pglite' const pg = new PGlite(); Internally, the constructor instantiates a Wasm module and stores the promise in the object's waitReady field. Most of the methods on the PGlite are async, and they await the promise.$

Top-level await
In principle, a library could use top-level await to do the initialization step internally, rather than requiring it in the application code. I'm not aware of any libraries that use this approach directly though.

It does have transitive effects on any code that imports the module:

Here’s what happens when you use top-level await in a module:

The execution of the current module is deferred until the awaited promise is resolved.
The execution of the parent module is deferred until the child module that called await, and all its siblings, export bindings.
The sibling modules, and siblings of parent modules, are able to continue executing in the same synchronous order — assuming there are no cycles or other awaited promises in the graph.
The module that called await resumes its execution after the awaited promise resolves.
The parent module and subsequent trees continue to execute in a synchronous order as long as there are no other awaited promises.
In other words, for the application code, it's as if it awaited the init function at the top of the module.

ES Module integration
Both Node and Deno now support importing Wasm modules directly:

import { add } from "./add.wasm";

console.log(add(1, 2));
My understanding is that it's equivalent to the following code:

const wasmInstance = await WebAssembly.instantiateStreaming(fetch("./add.wasm"));
const { add } = wasmInstance;
AFAIK, it has the same implications on module execution as an explicit top-level await does.

Sychronous instantiation
A final option is to synchronously instantiate the module — either using Node's readFileSync to load from a file, or by embedding the module as base64:

const bytes = Uint8Array.from(atob('AGFzbQEAAAABBwFgAn9/AX8DAgEABwcBA2FkZAAACgkBBwAgACABags='), c => c.charCodeAt(0));
const inst = new WebAssembly.Instance(new WebAssembly.Module(bytes));
console.log(inst.exports.add(2, 3)); // Prints 5

1 1 7

Reposted by Mariano Guerra

tom larkworthy @larkworthy.bsky.social · 7d

wow I spent a fuckton of time writing a compiler/decompiler for Observable 1.0 and now it is ISC licensed in Notebook Kit and it does Typescript and Notebook 2.0 syntax and everything! This is amazing.

1 3 10

Reposted by Mariano Guerra

Ivan Reese @spiralganglion.com · 6d

Anyone following me from the world of gamedev? Wanna work with me? Have friends / followers who might? Get in while the getting is good!

Ink & Switch @inkandswitch.com · 6d

It's that time again: ✨we’re hiring✨

We're looking for a @godotengine.org IDE Engineer to help us build the next generation of collaboration tools inside the engine itself! More detail here: inkandswitch.com/jobs/godot-ide-engineer

(Remote role 🌍🌎🌏)

Godot IDE Engineer

Help build native, visual version control for collaborative game development in Godot

inkandswitch.com

1 7

Reposted by Mariano Guerra

Tomas Petricek @tomasp.net · 9d

I'm at #uist2025 presenting our new work with @jonathoda.bsky.social!

𝗗𝗲𝗻𝗶𝗰𝗲𝗸 is a computational substrate for end-user programming that makes it easy to implement programming experiences like programming by demonstration, collaborative editing and more!

tomasp.net/academic/pap...

1 15 30

Reposted by Mariano Guerra

Thomas Steiner @tomayac.com · 9d

📢 New #WasmAssembly podcast episode: CG, WG, W3C, Lively — #Wasm standardization with Thomas Lively!

We talk about Thomas' role as co-chair of the #WebAssembly Community Group at the W3C and the two proposals he champions.

🍿 www.youtube.com/watch?v=MDGq...
🎧 wasmassembly.libsyn.com/cg-wg-w3c-li...

CG, WG, W3C, Lively—Wasm standardization with Thomas Lively - WasmAssembly

YouTube video by Chrome for Developers

www.youtube.com

2 4 10

Reposted by Mariano Guerra

WebAssembly from the Ground Up @wasmgroundup.com · 10d

An interesting article about how Figma moved from WebGL to WebGPU —

Figma rendering: Powered by WebGPU
→ www.figma.com/blog/figma-r...

Also talks a bit about their overall app architecture, and how they use #wasm.

But how do we actually use WebGPU?

Our renderer is written in C++. We compile this C++ code to WebAssembly (Wasm) using Emscripten, in order to use it in the main Figma application. But we also compile our C++ renderer code into a native x64/arm64 application used for server-side rendering, as well as testing and debugging. So we needed a way to write code using the WebGPU C/C++ API and have it work in both cases, with minimal per-platform branching.

For Wasm, we decided to use Emscripten’s built-in WebGPU bindings support. This means that C++ WebGPU calls ultimately end up using the WebGPU browser API in JavaScript, even though our code is written in C++. We also had to write some of our own custom C++/JS bindings in cases where these built-in bindings weren’t performant enough.

1 3

Mariano Guerra @marianoguerra.org · 10d

The P in PDF stands for Perl

1

Mariano Guerra @marianoguerra.org · 10d

📰 Future of Coding Weekly

🎙️ FoC 78: Let's Take Esoteric Programming Languages Seriously

📕 Forty-Four Esolangs: The Art of Esoteric Code

🎥 Foc Virtual Meetup: September 2025

🔗 newsletter.futureofcoding.org/posts/future...

2

Reposted by Mariano Guerra

𝖒𝖆𝖋 @mrogalski.eu · 11d

What's Automat? See for yourself: www.youtube.com/watch?v=7Cwx...

Demo from LIVE 2025 (liveprog.org)

LIVE 2025 - Automat: Objects As Syntax Not Data

YouTube video by The LIVE Workshop

www.youtube.com

1 3

Reposted by Mariano Guerra

mechadense.bsky.social @mechadense.bsky.social · 12d

I 😍 love this. This is 🤩 amazing.
Drop down acess to the dependents. I.e. the locations answering the question on where is this currently viewed function used/called from?

Unison @unison-lang.org · 13d

✨ The new dependents view shows everywhere a definition is used, broken down by category, as a separate card in Unison Share and the Unison Desktop app.

Your codebase is a bidirectional graph! You should be able to walk it as such.

1 2 3

Mariano Guerra @marianoguerra.org · 14d

The one where I try to apply ideas from programming languages to UIs: lexical/dynamic scoping, effect systems, static analysis.

1

Mariano Guerra @marianoguerra.org · 14d

Yesteday I presented "The Art of the MetaComponent Protocol" at the FoC Virtual Meetup.

Alternative titles:

- Making a To Do App in 5 minutes and one line of JS

- VibeCard all the way down 🐢

🎥 youtu.be/3-rg-FPZJtk?...

2 8

Reposted by Mariano Guerra

Fred Hebert @ferd.ca · 15d

The rebar3 -> rebar4 kickstarter ends in a few hours!

Late pledges stay open, but rewards (T-shirt, mug, stickers) disappear with the campaign.

We're seeking a more sustainable future for #Erlang build tools, and this campaign helps support this goal: www.kickstarter.com/projects/pee...

From Rebar3 to Rebar4: Integrating with Erlang/OTP

Building on top of Rebar3 to Fully Integrate with Erlang/OTP for All BEAM Languages, creating Rebar4 the next generation build tool.

www.kickstarter.com

3 8

Mariano Guerra @marianoguerra.org · 15d

TIL

en.wikipedia.org/wiki/Oracle_...

Reposted by Mariano Guerra

Patrick Dubroy @dubroy.com · 16d

PL folks —

For @ohmjs.org, I’m looking at how to support fully incremental pipelines (eg parsing → codegen, all incremental). I know about Salsa (github.com/salsa-rs/salsa); what else should I be looking at?

GitHub - salsa-rs/salsa: A generic framework for on-demand, incrementalized computation. Inspired by adapton, glimmer, and rustc's query system.

A generic framework for on-demand, incrementalized computation. Inspired by adapton, glimmer, and rustc's query system. - salsa-rs/salsa

github.com

4 1 5

Reposted by Mariano Guerra

MIT Press @mitpress.bsky.social · 16d

In his playful collection "Forty-Four Esolangs," Daniel Temkin (@dtemkin.bsky.social) challenges conventional definitions of language, code, and computer, showing the potential of esolangs—or esoteric programming languages—as pure idea art: mitpress.mit.edu/978026255308...

A copy of "Forty-Four Esolangs: The Art of Esoteric Code" by Daniel Temkin. The cover features an image of a blue sky with clouds with various vertical colorful stripes overlaid across it.

1 11 27

Mariano Guerra @marianoguerra.org · 16d

tfw neovim (with lazyvim) has more lag than zed.

Reposted by Mariano Guerra

Patrick Dubroy @dubroy.com · 17d

Finally got around to reading Build Systems à la Carte (dl.acm.org/doi/pdf/10.1...), it's really great (like everyone says).

I love papers like this, that take a well-known, messy, unloved area and propose a useful organizing principle for it.

Build systems are awesome, terrifying, and unloved. They are used by every developer around the world, but are rarely the object of study. In this paper we offer a systematic, and executable, framework for developing and comparing build systems, viewing them as related points in landscape rather than as isolated phenomena.

By teasing apart existing build systems, we can recombine their components, allowing us to prototype new build systems with desired properties.

1 8 21