Jons Mostovojs @jonn@social.doma.dev

Yesterday, Jonathan Brouwer defended his master thesis on implementing dependently typed languages in the Spoofax language workbench. You can find the pdf at https://repository.tudelft.nl/islandora/object/uuid%3A7bf3c0f5-71fb-4e08-bcdb-1c873c7e1e63

I was really pleasantly surprised at the nice things that modern language workbench technology has on offer, and would definitely consider it when prototyping a new language. The main drawback is the limited control over how implicit arguments are solved, but since a prototype will often not even have implicits, even a basic unifier is nice to have.

One thing I'm still missing is a way to export the specification of the type system to a proof assistant so I can prove things about it. Perhaps Statix2Agda would be a nice topic for another master thesis?

white people i am begging you to recognize that emotional blankness/neutrality is not a positive attribute but the fact that you value it is a sign of how your society has been engineered to divorce you of your humanity

Today on Between Two Cairns, @bradkerr and I review Cold Wind Whispering and answer a bunch of questions from Gus L.

https://www.buzzsprout.com/2042709/12697777

To sum up where the Fediverse is right now:

1. @EU_Commission backs it
2. The @w3c backs it
3. @fsf backs it
4. @eff backs it
5. Twitter Co-Founders @ev and @biz back it
7. Web browsers like @mozilla and @Vivaldi back it
8. Prominent 3rd party client devs like @paul backs it
9. @gruber and @davew back it
10. @georgetakei backs it

Am I missing anyone?

Oh yeah, YOU back it!

Problem 2: New folks are exposed to too much chatter about fancy type theory. It burns them out before they get even started, hence they get pushed towards keeping things "pragmatic". Languages which are "multi-paradigm", "immutable by default, but mutation is allowed" and so on.

To use an analogy - vim, on a much smaller scale, has a similar problem. The learning curve is steep and requires a lot of motivation to get started. Now imagine if the most common topic of discussion amongst vimmers was the theory behind movement operators and they focused more on proofs of some key combinations being the shortest way to do something. Such an environment would turn people off vim very fast. Thankfully this is not the case, and vim still has a growing and passionate community.

Pushing newbies away has a very real cost on the evolution of a community. It's an interesting realisation I had recently - Programming language tooling and ecosystem work is a young person's game. People burn out, family and friends get more important, and they have less time to contribute as prolifically as they used to. If a community doesn't focus on people new to the community, it will stagnate.

So what is it that is the most common topic of discussion amongst vimmers? It's *how to do something in vim*, how to use the key combinations to the fullest, which plugins are the most useful in the ecosystem, and how to improve the ecosystem itself.

The fancy type theory and the mathematical / categorical aspects of Haskell have their place of course. And people *will* discuss what they find most interesting, agreed. However, we should take steps to insulate new people from these discussions by making it so that they don't have to wade through forum discussions or blog posts to get answers to basic questions.

3/n

#Haskell #FunctionalProgramming #Rust

Not an Org exporting extension per se, but each of my projects now has a workflow that runs a script on push, so I can write Org documents for my projects’ repositories and get a Markdown README file generated automatically.

https://jeffkreeftmeijer.com/org-readme/

#emacs #orgmode

"don't over-engineer human relationships like we did single page apps" 🙏

🗑️

How do you tell the difference between a chemist and a plumber? #ChemiVerse #Chemistry

THE CULT OF PAIN

Computing is indeed a very special field of engineering. Whereas everyone else in the whole known world tries to improve upon his tools in order to make his craft more efficient, software engineers do the literal and complete opposite. Every little problem that can exist is meticulously described, standardised, and almost religiously cherished, with enormous temples of shit erected around them for support and in order to stop everything for falling apart. Imagine if civil engineers used concrete recipes from Ancient Rome. The Pantheon still stands, after all, so the old mix must be good for something. Right? Only if you disregard the fact that everything around The Pantheon has long since fallen apart.

But in computing industry, this approach isn't only frowned upon, it in fact thrives. Teachers force the knowledge of old and laughably bad tools onto their students, when even a mediocre university student can come up with better and more apt instruments. The problems of old instruments are instead put on the pedestal and surrounded with a cult. THE CULT OF PAIN AND SUFFERING. The ability to overcome this pain and move on is celebrated instead of being ridiculed like it should in any sane world. Any attempt to improve the situation is met with hostility. Have you ever seen discussion threads about adding support for Rust into the Linux kernel? Half of self-proclaimed C developers hate even the notion of such desecration of their sacred cow, even though the kernel code quality is already far from ideal and will only become worse with time. I'm not sure bringing Rust in will help the situation, it just might be too late. I'm hopeful it is, because enough is enough.

In fact, the situation around Eunuchs[1] OS family and C programming language might just be the best manifestation of this cult. Consider the following example: one of the famous yet peculiar quirks in C is that variables are not initialised by default. In fact, using a value from an uninialised variable is undefined behaviour, meaning your program is incorrect and your compiler can just throw your code out of the window and replace is with a bag of dicks. There is no sane program that would depend on any sort of behaviour that a code like this results in. Yet, in the 50 years since C was conceived, this feature has not only not been elimited entirely, it has carefully been preserved. Compilers give warnings that a variable might not be initialised. Static code analysers are created and sold as commercial software to allow detecting this kind of errors. Numerous CVEs[2] exist because of someone somewhere having forgotten to initialise a variable. Dynamic tracing and various undefined behaviour sanitisers are used to find the bugs caused by this.

But have you ever wondered, how much it would take to eliminate undefined behaviour caused by uninialised variables in C? About a week's worth of time for a not-so-bad programmer who knows how compilers work. Per compiler, probably, which gives us about a month for all relevant C compilers today. That's it. Tracking variable initialisation and reads in compile time via SSA[3] and adding zeroing in case of uninitialised read is all it would take. And since uninitialised variables containing zeroes would totally fit the description of undefined behaviour, no sane code would be broken by this addition. Yet, it has not happened yet. Not by default and not in a popular compiler, at least. Instead, "features" like this one are celebrated by C programmers. They are considered challenges that one must overcome and learn to deal with in order to become the true programmer. Imagine, if instead of an airbag your car had shrapnel that was launched in your face in the event of collision. Sure, people would drive more carefully, but the idea is stupid and probably nobody would want this.

Lose no hope though. The situation is improving, albeit slowly. Just as it is in science, the adepts of old ways die of old age. Linux was forced to adopt Rust not because it is a better language than C, but because C programmers are retiring en masse and nobody else wants the job. Maybe, the cult will die out just as all cults do.

[1]: Thanks to my dear friend from Stereophonic, @scathach, for introducing me to this apt term, as it is truly the best in describing this piece of technology.
[2]: The C in CVE stands for the C programming language and you cannot convince me otherwise.
[3]: Static Single Assignment, https://en.wikipedia.org/wiki/Static_single-assignment_form

Just been looking at Substitoot by @virtulis https://substitoot.kludge.guru/

A really neat alternative to #FediFetcher: It's an extension for Firefox or Chrome, that will load missing replies from the home server, when looking at specific posts.

Unfortunately my daily driver is actually Safari (and I use mostly apps for mastodon these days, anyway), so it's not for me, but I think it's pretty cool.

Bit of a long shot, but could my good mastodon follower folk give me some boosts?

I'm starting work on a documentary podcast series about the future of space; renewable/sustainable technologies, commercialism in the sector and the public's perception of it all.

I'm hoping to connect with people who know space to complement my client's contacts, so any signal boosting would be appreciated!

Huge news 🥳

WordPress now has 3,000 ActivityPub plug-in installs.

Which means that on a per node basis, WordPress’s install base is appr. 25% comparative to the size of Mastodon’s install base.

If I were to hazard a guess, WordPress is now the 2nd largest Fediverse server software in terms of active nodes.

In terms of Fediverse server installs, it’s more than possible that WordPress could overtake Mastodon.

https://mastodon.social/@pfefferle/110258116938066671

@fediversenews

Visually simulate git commands before running them https://github.com/initialcommit-com/git-sim