Fernando Borretti

As someone working on a language myself, I found this to be very high-quality material! It aligns with a lot of my thinking, and it’s educational.

A random part of interest: I followed the link about how linear types and exceptions don’t mix: https://borretti.me/article/linear-types-exceptions In it, the author explains how linear types always need to be explicitly destroyed, and if you end up in a “catch” block, you can’t easily go back and destroy things that are now out of scope, which control flow got interrupted while doing things with. “Why not just destroy things when they go out of scope?” I thought. The author addresses this, saying that types that you have to “consume” “at most once” are called affine types, and the compiler can clean them up for you, and it solves the problem with exceptions. Rust has affine types, and you don’t have to explicitly “destruct” every string/object/resource using the appropriate destructor for that type, manually, as you do with linear types (of course, the compiler will make sure you do it, but you have to do it).

So why does Austral use linear types, not affine types? The reasons given do not really resonate with me (but I’m not a systems programmer); it’s that the compiler would have to insert hidden function calls, and secondarily, for temporary/intermediate values, the order of invocation might not be obvious; plus, maybe the programmer not doing something with a value is a mistake. I’m really glad the reasons are written…

In earlier times, before Google or OS X even existed, long before "automatic updates", it used to be own experience that Microsoft's pre-installed Windows programs would run generally faster and with fewer issues (read: none) than third party software that a Windows user would install. This was also the case with software downloaded from Microsoft that a Windows user might install. Hence I thought perhaps MS Word today might run smoother on a Microsoft laptop than an Apple laptop. I'm not a Windows user anymore so I have no idea.

For reading, editing, creating Word documents, the TextMaker Android app seems to work. Size of recent version I tried was 111MB, startup is quick. Paid features are non-essential IMHO.

https://www.softmaker.net/down/tm2024manual_en.pdf

A personal favourite program for me is spitbol, a SNOBOL interpreter written in a portable assembly language^3 called MINIMAL. I'm using a 779k static binary. SNOBOL is referenced here:

1. https://borretti.me/article/you-can-choose-tools-that-make-you-happy

The Almquist shell is another favourite of mine. It's both the "UI" and the language I use everyday to get stuff done on the computer. Like Microsoft Word makes some HN commenters unhappy, it seems that the UNIX shell makes some "developers" unhappy.^2

But the shell is everywhere and it is not going away.

IME, old software from an era before so-called "tech" companies funded by VC and "ad services", still works and I like it. For example, sed is…

This website (and all the author's libraries) was such a refresher. It has been important for me to not run away from CL (again). At that time, the "official" website, the first Google result for CL looked like this: https://web.archive.org/web/20160305135106/https://common-lisp.net/ Fortunately, they revamped it circa 2018: https://common-lisp.net/ (work mainly due to @mmontone if I'm not mistaken). Since then, the Cookbook was expanded with useful content (it was kind of hard to find up to date information online, on even simple matters like how to build a binary) and we got some useful lists too, like https://github.com/CodyReichert/awesome-cl and a list of (current, existing) companies: https://github.com/azzamsa/awesome-lisp-companies/ Hopefully it's easier than ever to have your questions answered and start hacking in Lisp!

Another very helpful resource by Fernando was his state of CL ecosystem: https://borretti.me/article/common-lisp-sotu-2015 It really helped have an overview of the ecosystem, pick libraries and work on consolidation. I compiled one for 2020 here: https://lisp-journey.gitlab.io/blog/state-of-the-common-lisp-ecosystem-2020/

(ps: yes people, you can avoid Emacs and use VSCode to have a good experience! and even Atom, Jupyter notebooks and more. See https://lispcookbook.github.io/cl-cookbook/editor-support.html)

This is something you can do with a self-diagnosis. If reading the literature on autism gives you processes that improve your life, you don't need the diagnosis to confirm that. The life improvements were the end-goal in the first place.

This kind of presupposes that you have suspicions about autism rather than just something in general. If you think you have autism, you're can target that literature anyway regardless of the diagnosis, while if you have no concrete suspicions, you'll be firing blind, and probably miss a lot more than if you could nail it down to one diagnosis.

By the time I got mine, I didn't need the processes, since I'd figured those out by myself, so the diagnosis is just a nice piece of paper pointing to a road I've already walked.

For ADHD though, that story is very different, since step zero there really should be medication,[1][2] and that is locked behind a diagnosis.

[1] https://pmc.ncbi.nlm.nih.gov/articles/PMC2515906/

[2] https://borretti.me/article/notes-on-managing-adhd

I think this could be useful for the type of person that uses uses todo lists to help them tackle lots of small tasks that they intend to do immediately but somehow get distracted mid-action from and never finish (and then forget about altogether). As described in this blog post that front-paged hn some time ago:

> When I notice a micro-task like this, my instinct is not to do it, but to put it in the todo list. Then I try to do it immediately. And if I get distracted halfway through, it’s still there, in the todo list.

https://borretti.me/article/notes-on-managing-adhd

The problem with this approach is that recording tasks become a good amount of relative overhead compared to the 'micro-task' if it involves pulling out your phone, and pulling out your phone also introduces a potential distraction. So, having something that is single purpose and as low-friction as possible is appealing.

I'm skeptical that this is actually any better than using a smart watch that you can dictate to though.

The author takes great care to rebut a common theme among objections to the proposal - “this isn’t necessary if you just write code better”. I am reminded of this fantastic essay:

> If we flew planes like we write code, we’d have daily crashes, of course, but beyond that, the response to every plane crash would be: “only a bad pilot blames their plane!”

> This doesn’t happen in aviation, because in aviation we have decided, correctly, that human error is an intrinsic and inseparable part of human activity. And so we have built concentric layers of mechanical checks and balances around pilots, to take on part of the load of flying. Because humans are tired, they are burned out, they have limited focus, limited working memory, they are traumatized by writing executable YAML, etc.

> Mechanical processes are independent of the skill of the programmer. Mechanical processes scale, unlike berating people to simply write fewer bugs.

(https://borretti.me/article/introducing-austral#goals)