Closed marianoguerra closed 2 years ago
🐢 Prototyping Logo in natto.dev 🌉 History of Sketchpad 🧰 Kinds of Tools ⭕ Shape of Data
🔗 Tarot Reader via Tom Larkworthy
So the AI tarot reading app is done: https://thetarot.online/index.html
It has been programmed entirely within Observable. Production traffic is routed through the developers notebook if you have it open, so you can observe the system live. I exploit observables dataflow so each step of the processing pipeline is cached, so you can see exactly where a problem occurred, and thanks to hot code reload, you can fix a bug and have the pipeline continue without rerunning prior steps allowing easy iterative programming workflows. Of course, because Observable notebooks are executing Javascript, you can attach a debugger too (even programmatically)
One click forkable, MIT licensed.
This is what I think the future of software development should look like. But I am struggling to communicate this well. The idea is to make cloud programming feel local, to exclusively test in prod, because when you are hitting third party APIs its a waste of effort mocking a staging environment, or a local environment. I want to remove the thick layers of indirection in the development process that no longer make sense. Forget git, forget toolchains, just straight to prod using modern Javascript, debugged with the authoritative debuggers built into browsers.
🌉 No-code History: Sketchpad - A man-machine graphical communication system (1963) via Mariano Guerra
Fifth post in the "History of No-Code" series
📝 The shape of data via Jamie Brandon
Some (unpublished) musings on how data is represented in programming systems
🐦 Tweet from @nickarner via Nick Arner
Can’t stop thinking about how much I wish I could do this with my IDE (in my case, almost exclusively Xcode):
🐦 Nick Arner: Imagining an IDE where I can better query the running status of my program / app
Do you have any example of a UI Widget type created in the last 20 years? (like slider, select, radio button, checkbox, things you would have on a UI builder palette)
Been thinking today about “handoff mechanisms” and how they're essential in networking/communications infrastructure, but we don't have a similar notion in software (that I know of).
This came up while working on an Obsidian plugin to replace the built-in “graph view”. One of the design constraints was that it handles different scales appropriately, from deterministic approaches at small scales -> physically simulated at medium scales -> probabilistic/heuristic at large scales.
I didn't want there to be any modes and I wanted there to be consistent observed behaviour, so I started referring to this as “pixel-perfect handoff”.
🎥 DIY haptic input knob: BLDC motor + round LCD via Deepak Karki
I recently came across this interesting piece of programmable tech
Other than capturing my attention for being an interesting product, it got me thinking of new hardware extensions (or complete systems) that would enhance/change the coding experience.
We always discuss what kind of digital UIs would make programming simpler and more intuitive, so I was wondering if someone has looking into new kind of hardware I/O which would change how we program today. In fact new hardware could spur new mental models and digital interfaces for programming! (Think of how a mouse / touchscreen is central to something like Blocky/ MIT Scratch).
I have no experience in this field, just wanted to get a discussion going and see if someone with a bit more familiarity could chime in!
🧰 There are two kinds of tools: user-friendly tools, and physics-friendly tools via Kartik Agaram
Teaser:
There are two kinds of tools: user-friendly tools, and physics-friendly tools.
Physics-friendly tools force you to grow in a specific disciplined way, while user-friendly tools save you the trouble of a specific kind of growth and discipline.
Whether you use the saved effort to grow somewhere else, or merely grow lazier, is up to you. Most people choose a little of both, and grow more leisured, and we call this empowerment.
Physics-friendly tools feel like real tools, and never let you forget that they exist. But if you grow good enough at wielding them, they allow you to forget that you exist.
User-friendly tools feel like alert servants, and never let you forget that you exist. If you grow good enough at wielding them, they allow you to forget that they exist.
When a tool allows you to completely forget that you exist, we call it mastery. When it allows you to completely forget the tool exists, we call it luxury.
(Alright, I'm going to quote the whole thing at this rate. Skip to end.)
There’s fundamental-limit phenomenology around minimum-viable tooling. A machine that flies has to have a certain minimal complexity, and building one will take tooling of a corresponding level of minimal complexity.
Periodically, there is a bout of enthusiasm in the technology world for getting past the current limits of minimum-viable tooling, and so you get somewhat faddish movements like the no-code/low-code.. Premature user-friendliness is the root of all toolchain jankiness.. Simpler, more user-friendly tooling is the result of improved understanding, not increased concern for human comfort and convenience.
🎥 Prototyping a Logo programming environment inside natto.dev via Mariano Guerra
Prototyping a Logo programming environment inside natto.dev
[x] Change Month and Week Number
[x] focWeekExport 2022-01-19 2022-01-26
[x] Summary
[ ] Hashtags
[x] Check that comment links work (push weekly dump with channel summaries)
[x] Check to mention right person for moved messages
[x] Update Search Index
[x] Download New Attachments
[x] Update links
https://tinyletter.com/
https://tinyletter.com/marianoguerra/letters/
http://localhost:8000/history/
https://marianoguerra.github.io/future-of-coding-weekly/
https://stackedit.io/