Pinned toot

Researching new ways to write software that make it easier for newcomers to understand rather than for insiders to maintain. Systems that build easy, reward curiosity, encourage lots of forks, encourage deleting unused features, make society more anti-fragile.

Current project: a zero-dependency Assembly language for x86; Linux without GNU.

(Previous intro:

My new Assembly syntax is now 4/5ths bootstrapped in itself. Just one phase left:

The previous phase took 7 weeks, but what's a factor of 7 between friends 馃槃

Some LoC stats (total, and excluding comments/tests):

hex: 1511/144
pack: 7348/1054
assort: 1318/284
dquotes: 2694/497

Similarly, some executable sizes:

hex: 22KB/3KB
pack: 37KB/8KB
assort: 22KB/5KB
dquotes: 27KB/6KB

/cc @rain @vertigo @kragen

Today I learned that the reason we mostly encode [CARRIAGE RETURN + LINE FEED] and not [LINE FEED + CARRIAGE RETURN] has to do with teletype machines (these were typewriters hooked up to computers that supported input and output). Because CR is moving the print head about 8 inches right-to-left, and LF is scrolling the paper down ~1/4", LF took less time. If you sent CR/LF to certain models of teletype it could do the LF *during* the CR, saving a little time.

We use the word "boilerplate" a lot at work. It's such a strange phrase that seems like it's probably traveled far from its original meaning, so I looked up what that meaning was.

It goes back to newspapers. Large advertisers and content syndicates would distribute ready-to-go printing plates to local newspapers that could easily just go onto the press and be ready to print without any modification. These plates resembled rolled steel that was used to make boilers.

Hence: boilerplate.

@kragen @vertigo Do either of you happen to know why a pointer access to inside the heap would segfault if it was above the program break?

Here's an example program that strides through the heap dereferencing pointers until it segfaults. I was expecting it to segfault when it hits the program break, but it seems to segfault long before.

To the extent undistracted deep work is a well-posed concept at all, the biggest disruptor of it is not social media but the need to make money. Every waldenponding evangelist I know is rich enough or securely-incomed enough to not be distracted by money-making.


I can barely handle this gardening shit. It's so nakedly, unapologetically cutthroat. Writers might have to murder their darlings, but gardeners have to thin seedlings. *shudders* Life is just brutal.

I just had an interesting chat ( with a contributor to SubX, my bootstrapped Assembly syntax. In response:

a) SubX now has sandbox branches where people can reimplement existing features.

b) I'll be publishing in-progress work. In the past wanting to keep HEAD passing tests has caused changes to accumulate for weeks at a time. Now they'll start getting feature branches like

Each PR at now has context and instructions.

My new Assembly syntax is making progress towards being self-hosted. It can now create ELF binaries with data, opcodes and immediate/displacement operands. What's left:

a) Packing mod/reg/rm operands and scale/index/base operands into single bytes. (ETA: 2 days)

b) Handling string literals. (ETA: 1 week)

c) Support for labels. (ETA: ???. 3 months, if past history is any guide.)

Then: Goodbye C! Goodbye dependencies I don't understand! Hello, *true* collaboration.

There is something about writing the statement 'import time' that makes me feel supremely powerful.

Thousands of programmers have spent countless hours abstracting the complexities of time such that now I can just import a library and leverage all of their hard work for myself with little understanding.

I am truly a blind, idiot god. Feel the power of my ignorance!

How Arthur Whitney defines syscalls (admittedly in C)

$ cat A.S

S(n) .globl n;n:;mov %rcx,%r10;mov $__NR_#,%rax;syscall;ret;




the enterprise software omphalous:

design software to reflect organizational structure


restructure organization


Tired: Good design is about decomposing systems into components, each designed to hide a single major design choice. [1]

Wired: Since design mirrors the communication structure of the creating organization [2], good design is about decomposing the organization into teams, then encapsulating each team's services behind interfaces.



In the last few months:
- Tumblr purged adult content (and a bunch of stuff it misindentified).
- Flickr purged free storage above a limit of 1000 photos/account.
- Myspace deleted 12 years' worth of music.

And Google+ only has two weeks left before Google pulls its plug.

Back up your accounts!

And if you can, consider donating to the Internet Archive.

So weird that using a laptop as a "thin" client is so much more battery- and RAM-intensive than simply installing native applications and running them locally. It's almost like abusing a technology that was never intended for this purpose is a bad idea.

Show more

Server run by the main developers of the project 馃悩 It is not focused on any particular niche interest - everyone is welcome as long as you follow our code of conduct!