Manuel Simoni
@msimoni
Followers
3,718
Following
1,593
Media
169
Statuses
3,173
geek of programming languages, operating systems, and hypermedia platforms
Joined April 2008
Don't wanna be here?
Send us removal request.
Explore trending content on Musk Viewer
Davido
• 173622 Tweets
WONWOO
• 108691 Tweets
からくりサーカス
• 99707 Tweets
ケンタッキー
• 94292 Tweets
ニンテンドーミュージアム
• 76378 Tweets
FAYEYOKO BTS 1ST FANMEET
• 73841 Tweets
BTS NUNEW 1ST CONCERT EP2
• 69944 Tweets
#swallows
• 60596 Tweets
フォーエバーヤング
• 42260 Tweets
青木選手
• 31290 Tweets
#しぐれういリアルライブ
• 23457 Tweets
青木さん
• 23100 Tweets
Alcaraz
• 19769 Tweets
Wizkid
• 18850 Tweets
サンライズジパング
• 15720 Tweets
Cassper
• 13913 Tweets
TORE
• 13298 Tweets
ダービー
• 11652 Tweets
#クイズフェスティバル
• 11534 Tweets
שנה טובה
• 10514 Tweets
One area that 80s/90s Apple absolutely owned was the _worldbuilding_ aspect of OS design. You look at these screenshots and you feel like you _are_ in some place.
8
28
309
What users really want are sites that look and work like this, which is why I don't find Figma interesting.
McMaster-Carr, the gold standard of web design. They didn't have anyone to look up to, there is nothing like it. They didn't use a design framework. They focused on fundamentals of design, not fads and fashion.
They didn't have to do it, but they did.
123
647
7K
1
24
242
Wake me up when fictional UIs look like this
Let's give a huge round of applause for
#TheExpanse
CGI team👏👏.
I haven't seen any other show with such a level of detail given to screen UIs and they only make an appearance for like few seconds.🤯🤯
Incredible work as always
#TheExpanse605
@TheExpanseWR
@ExpanseOnPrime
18
69
694
3
36
231
Unix pipes took nine years from initial idea to first implementation
1
60
213
Improving filesystems is probably one of the highest leverage approaches to improving OSes.
In BeOS every file had extended attributes.
Your email inbox was an ordinary folder that simply displayed those attributes (Subject, From, Status, To) of the email files stored in it.
8
13
207
Some people, even some programmers, don't know how Git organizes its data. Here's a good cheat sheet:
3
28
190
Rewriting the same program over and over is a superpower.
I've rewritten the same Lisp interpreter about 10 times in as many years, and finally it's in a shape that I like.
14
14
190
@jlongster
It does help me. 90%+ of the time, a variable won't be modified. `let` sticks out and tells, me "this is one of those rare cases where the variable will be modified".
4
0
182
"CPUs do not care about common sense or big-O notation"
1
31
178
Antarctica has some of the best architecture on the planet. It's like
@usgraphics
says, if you don't care about aesthetics at all, you often get the best aesthetics.
4
7
178
SSDs and Ethernet now have higher throughput than RAM.
"This shift in hardware balance is probably the biggest change to fundamental assumptions in database architecture since SSDs started to become a thing, and most people haven't internalized the implications yet." -
@jandrewrogers
The race now is to optimise for latency.
9
36
221
7
25
149
Unix pipes took nine years from initial idea to first implementation.
That implementation was done in one night.
8
27
140
I've said it before, and I'll say it again: Common Lisp has the best error handling system of any language.
(It's very much like an effect system. However, effect systems always build-in continuations, which aren't actually needed most of the time.)
4
16
118
It's wild how much power was unlocked by making parts of a text clickable.
2
14
118
Something like Rust but with a GC would probably be a nice language (and would still work for 80% of the things people are using Rust for).
62
1
115
The core idea of Emacs is to have an expressive digital material and an open-ended, user-extensible set of commands that manipulate that material and can be quickly invoked.
Obviously, this model can be fruitfully applied to any digital material, not just plain text.
10
11
105
Curmudgeonly take: most often, you don't want visual zooming (making a graphical object smaller or larger) - you want semantic zooming (making the information (string of bits) you display about an object shorter or longer)
Zoomable User Interfaces (ZUIs) are really cool.
They allow you to zoom out to get the big picture and then zoom in to examine the details.
34
97
694
7
7
103
In the branding of personal computing systems, I think it's always good to err on the side of cuteness. General Magic with their Magic Cap OS did that very well.
4
4
99
"We present Wasocaml, an OCaml to Wasm-GC compiler. It is the first compiler for a real-world functional programming language targeting Wasm-GC"
2
23
101
TempleOS still has a sizable following, demonstrating that you can't be too far-out as an OS designer.
6
3
98
I have yet to see a TypeScript program that doesn't have garbage like this.
I can tell just eyeballing this code that it delivers zero value.
14
6
94
"HTTP was design[ed] as a distributed realization of the Objective C (originally Smalltalk) message passing infrastructure [...]
Uniform Resource Locator is just the result of squeezing the term _object reference_ through the IETF standardization process."
4
26
113
Oberon is about 10,000 lines of code.
That's as much code as the PARSER of some programming languages (not naming names).
0
16
89
In well-designed operating systems, like classic Mac OS, there is a single uniform visual style and no developer needs to care about or waste time on styling.
7
12
89
Short intro to Church vs Curry types
(Makes the usual unfounded typecel claim that dynamic programs somehow are bound to have errors, but I'm used to that.)
3
10
89
When I started programming in the 90s there was a distinct sense of edginess and irreverence.
That seems to have been completely reigned in now (can't get those sweet FAANGbux if you're edgy).
Big opportunity for any company/platform that manages to bring the fun back to hacking.
16
2
87
I'm personally not interested in using the language Uiua (pronounced wee-wuh) but I appreciate its sense of sovereignty of language design.
1
15
89
Both the extremely skeumorphic design trend from a couple of years ago, as well as today's ultra-minimalistic trend are wrong.
Mac OS 8 represents the correct middle way.
5
10
87
Prolly trees are prolly one of the most impactful new data structures.
Think sorted database index, but with the same properties as a Git repo: identified by single root hash, structural sharing of data between versions, quickly snapshot-, sync-, and diffable.
Dolt is the world's first version controlled SQL database. To achieve this, Dolt uses Prolly Tree storage of schema and data laid out in a commit graph to achieve database version control at the storage layer.
Today's blog is about Dolt's Architecture.
1
1
30
3
12
85
My computing career started on classic Mac OS, where you didn't have a shell, or text-based config files, or even had to know what a "file path" is.
None of these concepts are necessary for a great computing experience.
5
1
85
"EMACS could not have been reached by a process of careful design, because such processes arrive only at goals which are visible at the outset ... Neither I nor anyone else visualized an extensible editor until I had made one"
2
22
83
This project is doing some interesting post-typewriter syntax explorations.
(And it's using space as word separator, as I've been suggesting.)
2
10
83
Plan 9's Acme and Emacs demonstrate that you can do pleasing* UIs with just typography and some accent colors.
(* for autists)
3
6
79
Description of Model-View-Controller by its inventor. Actually makes sense, compared to every other description of it out there.
3
13
79
"Younger programmers will be surprised by just how controversial an addition first-class functions were! Java omitted it initially, despite its designers being expert Lisp and Smalltalk programmers."
9
4
80
"He can't really program, so his code is very simple and robust."
(OH a while ago, but unforgettable)
4
7
80
There is no FP/OOP dichotomy. Both are useful tools, than can be fruitfully used together, even in the same program.
10
12
79
Forcing people to use it via government mandate is of course extremely on-brand for Rust.
8
12
77
Novel PL design has like a 99% failure rate
“Swift, the original idea was factor complexity (…) massively failed, in my opinion (…) Swift has turned into a gigantic, super complicated bag of special cases, special syntax, special stuff”
lesson learned from Chris Lattner on Swift
41
132
837
3
7
77
RIP Niklaus Wirth.
To honor him, make sure your programming language can be described in 17 pages, like Oberon.
Or at least make sure your syntax can be described in 17 pages.
2
12
78
I absolutely love the web page. They start with absolute beginner resources, and then you have intermediate stuff, and finally you have papers about the theory behind the language. Very well done!
3
19
76
Dynamic languages shouldn't have "truthiness": only true and false should be usable in IFs and other places, everything else should raise an error.
You lose some convenient punning ability, but the language is much simpler and more readable.
22
1
76
Another example of this is Obsidian Markdown - it's so complex, that unless you restrict yourself to a subset, your files will practically unparseable (except by Obsidian's proprietary parser).
Maybe "it's just a bunch of .md" files isn't such a great selling point, actually.
Two of the most important plaintext formats (HTML and C header files) are practically unparseable without massive effort.
3
1
49
4
1
74
The core idea of Plan 9 is that every component of the system pretends to be a filesystem.
What if every component pretended to be something even cooler, like a hyperlinked database?
9
5
73
Lisp is still an improvement over its successors due to its bottom-up, user-driven philosophy: every Lisp programmer is also a language designer.
Some scoff at the idea, but it works because the "market" decides which design innovations become part of the language.
5
8
71
Good post about learning Git:
The only way that works is to understand the objects that make up its conceptual space (blobs, trees, commits, branches, remote-tracking branches, remotes).
4
8
71
That's why I love Lisp syntax: it's the closest thing we have to notational freedom in plaintext-based systems.
“Achieving Self-Sustainability in Interactive Graphical Programming Systems” by Joel Jakubovic (2024)
Love this framing of finding “notational freedom”!
2
6
58
3
5
70
I don't find the idea of "democratizing" programming interesting.
I'm interested in advancing the state of the art for natural born programmers.
14
3
68
I'm sort of a defeatist when it comes to programming - I think it sucks and will always suck, and no amount of tech will be able to change that.
So I've looked for the simplest thing that lets me get through this mess in a somewhat acceptable fashion.
And I've found that in Lisp.
6
4
69
ColorForth has been one of the most influential PLs to my thinking.
It shows that if you design your language for graphical displays, and not for typewriters/teletypes, you can give semantics to arbitrary graphical properties of your syntax.
8
16
68
Reading the Photoshop 1.0 sources, and absolutely loving their use of whitespace
Also wondering why we need post-Pascal languages again?
5
3
66
UserTalk is a PL that exists in the middle of the text/structure continuum.
As you can see, it's outline-based so it has a general hierarchical structure. But within each line, you have the usual textual syntax.
This is already much more comfortable to edit than plain text.
5
10
67
Re-reading the Metrowerks PowerPlant GUI framework documentation, as one does, and it once again occurs to me that GUIs have been a solved problem since the 1990s, and everyone today is just sperging around.
6
10
67
A huge driving force behind Haskell's design was to make their code look good in papers. And they nailed it. Gotta admit that.
2
5
66
"[Our era] will be looked back upon as an intellectual reawakening, one specifically achieved through the public’s free access to the global library of information; meaningful intellectual findings that didn’t exist online earlier due to idea market inefficiency."
Smartphones onboarded the masses onto an internet that was previously dominantly colonized by libertarians/anarchos—while they held commitment to the ideal of a free marketplace of ideas, it was a marketplace with strong selection effects. Now we’re beginning to see the discourse
12
19
141
1
4
17
"a radically new OS design based on data-centric architecture: all operating system state should be represented uniformly as database tables"
3
5
66
Icons may seem small and unimportant, but I think they're central to establishing the specific vibe of a GUI.
3
6
62
1. Resumable exceptions (as in Common Lisp) are good. Thankfully, they're currently being rediscovered under the "effects" moniker.
2. With result values, you lose the ability to make global/scoped decisions about error handling, you always need to handle errors locally.
@HeavyPackets
It seems obviously better in an almost universal sense.
Does any reasonable arguments exist to want exception-throwing instead of “result-values”?
3
0
8
2
8
65
The original paper about the structure of DNA is one printed page, and fits on one screen when rendered as a web page.
0
9
58
If you want to create the future of programming, you need to create something that YOU want to use every day and that is better than anything else.
Then it will be easy to find others among the millions of super nerds on this planet that will collaborate with you.
4
11
63
@zetalyrae
I don't understand the HN reference. Wouldn't the person you describe typically also make a big deal about hating HN?
2
0
61
Ways web apps are better than native apps :
- no installation needed
- always up-to-date
- sandboxed
- can open multiple views/tabs
- can bookmark views
- can't prevent me from quitting
Those features are great and future OSes should adopt them for all apps.
8
8
101
Relational databases have been one of the most successful psy-ops in computer science.
10
9
57
Wondering if Apple Dylan's outline-based code editor was inspired by
@davewiner
's UserTalk?
UserTalk is a PL that exists in the middle of the text/structure continuum.
As you can see, it's outline-based so it has a general hierarchical structure. But within each line, you have the usual textual syntax.
This is already much more comfortable to edit than plain text.
5
10
67
2
4
62
Say what you will about Git, but it is an awesome design.
Content-addressed blobs and trees to capture filesystem state, a chain of commits for causality, and refs as mutable pointers into content space.
Arguably, you can't make it simpler.
3
4
62
People used to sell computers with imagery like this - a more civilized age.
2
6
62
This is a fun idea:
- store all your data in content-addressed storage (Git, prolly trees, ...)
- if a process wants to make changes it does so on a temporary ref ("topic branch")
- finally, changes are merged using a programmable, datatype-specific merge strategy (e.g. CRDT)
CausalRPC: treats data-modifying RPCs as topic branches modifying CRDTs in a Git-like repository, in order to get traceable distributed computation.
0
2
14
7
6
60
I didn't have Elon weighing in on type systems on my 2024 bingo card
@MarkovMagnifico
Done right, a compiler should be able to figure out type automatically. It’s not that hard.
Not that it will matter much in the AI future.
247
87
1K
4
4
57
Uhm, wow. "Practical compilation of fexprs using partial evaluation: Fexprs can performantly replace macros in purely-functional Lisp"
3
9
59
A threaded forum like (sadly, mostly defunct now) is my favorite tech communication format.
It's async-friendly; the ability to do longer posts makes people think more deeply; it's easy to see what's new.
I find chat rooms much too intense and distracting.
7
4
55
Using different text for the low and high IQ in the midwit meme is a sure sign of a midwit.
2
3
58
Dynamic language aficionados:
> create modern programming (Lisp)
> create graphical computing (Smalltalk)
> create the web (Objective-C, JS, Perl, PHP)
Static language enjoyer:
There's this trend where people say "There's no scientific evidence pure fp and static typing produces better results", despite it being true and there being a lot of evidence.
16
7
51
2
9
58
After LISP, its inventor McCarthy worked on another language based on speech acts.
It doesn't need data structures - because programs can simply refer to the past.
3
7
54
Demo of Japan's hypermedia-based TRON OS from the 1980s; note how a text document can contain links to other objects in the system
0
5
56
Java is running in browsers again. Nature is healing.
3
5
52
It's a weakly/dynamically-typed world. Strongly/statically-typed languages are just living in it.
8
14
52
A minimal Forth/Lisp hybrid with call-by-push-value semantics
("It appears to be both simpler than Lisp and more powerful than Forth.")
3
8
54
Twitter's "algorithm" is so stupid. Your feed should simply be all tweets by all people you follow, chronologically ordered. Everything else is a scam.
15
6
53
An in-depth historical account of the early days of the creation of Git:
Interestingly, Git didn't start out with a chain of commits - instead it had the concept of a changeset, with a before and after tree hash.
0
4
51
The idea that macros lead to unreadable programs couldn't be more wrong.
They lead to much more readable code, just like IF (a "macro" that expands to GOTO) often is more readable than using GOTO itself.
15
4
51
Photoshop's toolbar is practically unchanged since version 1.0, 35 years ago.
2
2
51
It's instructive to consider the number of "gotchas" you have to be aware of as a PL user:
- Java: a handful
- JS: dozens
- C: 100s
- C++: 1000s (?)
5
2
51
Chat interfaces won't supersede GUIs for most purposes.
Clicking buttons/menus requires much less effort than entering text into a chat, esp. mobile.
Voice input won't fly because people use computers in public/social situations, and don't want others to hear what they're doing.
2
4
49
Operating systems are the software equivalent of the Gesamtkunstwerk (total piece of art).
Programming languages, storage, processes, security, networking, user interfaces, graphic design, and - most importantly - vibe.
1
7
49
-- A Git-compatible VCS that does away with the staging area (and stashes), and instead has separate working dirs for every branch (branch = automatically stashed).
They have a detailed analysis of Git that explains their design:
3
4
49
Two of the most important plaintext formats (HTML and C header files) are practically unparseable without massive effort.
3
1
49
An OS must be useful by itself, before you even install any apps.
Classic Mac OS fits the bill: its desktop/Finder was essentially a "tool for thought".
Likewise, Emacs is useful even without any extensions.
1
7
49
JS is a great language, actually:
- Productive and convenient (since 2015's ES6; a masterpiece of PL evolution)
- Memory-safe
- Reasonably efficient
- Everyone knows it; massive ecosystem
(Yes, it has some murky corners (==, truthiness, ...) that you just need to steer clear of.)
5
6
48
Lol, this has been a meme in the catastrophic redesigns of GNOME and other Linux UIs, too: the dEsIgNeRs aren't even using the OS they're destroying, they're using macOS.
Long-time Microsoft employees explain changes in Windows:
Designers were handed full control over UX. Engineers who fought for usability over a slick-looking interface burned out and left after repeatedly being overruled.
125
574
4K
2
11
47
The idea, promulgated by tools like Markdown, that (technical) writing consists of objects like headlines, paragraphs, and lists is utterly wrong.
E.g. if you're documenting a programming language, your writing consists of objects like syntaxes, types, and functions.
6
7
49
Unix isn't going away, but once you accept that it's a dead end as far as personal computing is concerned, and backwards compatibility with it should not be a driving concern, you'll be able to think much more freely about what needs to be done to move forward.
5
5
49
Has there been any serious personal computer OS progress after Newton OS and BeOS?
(I am talking concepts - not animations, gaudy icons, transparent terminals, or finger gestures.)
16
3
47
I've been thinking about the "pull request" concept as a universal UI for making atomic changes against all kinds of data stores, e.g. in a CRUD app.
You make a proposed change on a "topic branch", various checks are performed to verify that it's OK to make the change, etc.
8
3
47
