Fernando Borretti

https://borretti.me/article/notes-on-managing-adhd Came across this a few months ago on HN here and there’s a fair bit of exposition on things you’ve mentioned. My personal takeaway from it was to try Todoist, which has been a complete game changer in my life. I’ve used other systems before but something about Todoist worked better for my brain (plus the mobile integration is awesome… my second best over the years was org-mode but the mobile story is way too clunky)

That's great, staying tuned! Plea to all language/languge ecosystem designers in 2023+ to design ahead for supply chain attack mitigations. Austral is one new language that appears to be doing so https://borretti.me/article/how-capabilities-work-austral ... Kudos to those retrofitting to existing ecosystems. I guess Flix is somewhere in the middle, not new (2015?) but still being designed/not huge legacy constraints. Anyway, thanks!

https://borretti.me/ 150 kilowords on Lisp, compilers, linear types, Rust, and broader software engineering opinions. Favorites: - Effective Spaced Repetition: https://borretti.me/article/effective-spaced-repetition - Unbundling Tools for Thought: https://borretti.me/article/unbundling-tools-for-thought - Introducing Austral: https://borretti.me/article/introducing-austral - Language Pragmatics Engineering: https://borretti.me/article/language-pragmatics - Lessons from Writing a Compiler: https://borretti.me/article/lessons-writing-compiler

In Lessons from Writing a Compiler, there is a great section on implementation strategies: https://borretti.me/article/lessons-writing-compiler

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…

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)

A few things that can help with memory: - spaced repetition for stuff that you use sporadically. I use Anki, it's great. For how to use it, this article is great: https://borretti.me/article/effective-spaced-repetition. I've found a positive feedback loop where the more I know how to do things without looking anything up, the more I use the CLI, the easier I remember things, the more things I discover, etc. I read once that when learning a new language, you should aim for content where you know 80%/90% already. It seems to be true for learning the CLI, and especially for integrating that learning into my day to day job. - sd (https://github.com/ianthehenry/sd) for lowering the cost of creating a "documented alias". Before that I made aliases with either alias, or bash functions, all starting with "," to quickly see all which are "mine" (I read that trick in an article that I can't find), now the more complex stuff is in sd with some documentation.

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…

I was quite impressed with Austral[0], which used Linear Types and avoids the whole Rust-like implementation in favour of a more easily understandable system, albeit slightly more verbose. [0]https://borretti.me/article/introducing-austral

An interesting design choice of Austral is the use of second-class references [0] in place of first-class references like Rust does. This makes the implementation of a borrow checker simpler at the cost of reduced expressiveness. Hylo (previously Val) [1] tries also to find a way of avoiding first-class references using value semantic and subscripts. [0] https://borretti.me/article/second-class-references; [1] https://www.hylo-lang.org/

Oh, it's going to have linear types like Austral... https://borretti.me/article/introducing-austral

https://borretti.me/article/composable-sql >Imagine a programming language without functions. You can only write code that operates on concrete values, i.e. variables or literals. So instead of writing a function and calling it anywhere you have to write these little code templates as comments and every time you want to “call” the “function” you copy the template and do a search/replace. >This would be tiresome. But that’s what SQL is. The concrete values are the table names. The code is the queries. And the function templates you have to search replace are your business logic, which must be inlined everywhere it is used.

Austral looks really cool for a modern programming language built around capabilities: https://borretti.me/article/introducing-austral

There are some really good guides on how to use SRS/Anki out there. In order of most basic to more advanced: http://super-memory.com/articles/20rules.htm https://borretti.me/article/effective-spaced-repetition https://andymatuschak.org/prompts/

I’m not GP, but here’s two articles I’ve found that have been extremely informative. https://borretti.me/article/effective-spaced-repetition https://gwern.net/spaced-repetition

A few other languages I think deserve a mention: * Carp: https://github.com/carp-lang/Carp * Nim: https://nim-lang.org/ * Zig: https://ziglang.org/ * Austral: https://borretti.me/article/introducing-austral

> trusting a URL which you shouldn't trust That's actually a feature in Ur/Web, which is a (very niche) language explicitly built for making web servers. It's sort of a domain-specific language though, so maybe it doesn't count. > making a function public when it should be private Nothing's gonna stop a programming mistake like that, but in languages with capabilities[0] you can restrict some functions to only be called when you have certain capabilities, and these capabilities can only be made to be acquired after authenticating a user, for example. [0]: https://borretti.me/article/introducing-austral#cap

I haven't seen anything like that. I don't think Rust ever had linear types. This blog post has an explanation of Austral's linear type checking: https://borretti.me/article/how-australs-linear-type-checker-works

It doesn't catch all signed overflow. If you define a function like this: int8_t abs8(int8_t n) { return (n >= 0) ? n : -n; } Even with `-ftrapv`, evaluating abs8(-128) will produce -128, because 127 is the maximum value for a signed 8-bit integer (so trying to get 128 wraps around to -128), but this isn't caught. However, both Rust and Ada do catch this. This article highlights this difference between C and Ada: https://borretti.me/article/signed-integers-asymmetrical I know Rust catches it because after I read that article, I tested it with Rust in debug mode.

> Where can I find a language with no garbage collection, nice sum types and no over complicated async syntax? Austral: https://borretti.me/article/introducing-austral It doesn't have complicated async syntax, because it doesn't have it at all :) https://borretti.me/article/introducing-austral#fn:async

The creator of Austral writes good fiction https://borretti.me/fiction/

I'm particularly excited for this too. We're starting to see a lot on the horizon: * Austral is using linear types for zero-cost memory safety [0] and then allows for borrowing on top of that. Val does something similar called mutable value semantics, which is pretty interesting [3]. * Vale brings borrow checking up to the regions level [1] which gives borrow checking benefits while still allowing mutable aliasing, which makes it much more flexible and ergonomic. * Cone uses borrow checking on top of any user-specified allocation strategy, such as single ownership, RC, GC, etc. [2] [0] https://borretti.me/article/introducing-austral [1] https://verdagon.dev/blog/zero-cost-memory-safety-regions-part-1-immut… [2] https://cone.jondgoodwin.com/ [3] https://github.com/val-lang/val

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.

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

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… (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)