Hacker News: taolson

New comment by taolson in "Steel Bank Common Lisp version 2.6.7"

taolson — Tue, 28 Jul 2026 21:03:33 +0000

Fun fact I learned from a Func Prog podcast: the name Steel Bank is a play on it's origin as Carnegie-Mellon Common Lisp (Carnegie made his fortune in Steel, while Mellon did so with Banks):

https://www.sbcl.org/history.html

New comment by taolson in "Astronauts told to return to ISS after sheltering over air leak repairs"

taolson — Fri, 05 Jun 2026 18:25:52 +0000

We actually did this in my freshman dorm room, as the paint color almost exactly matched the original Crest "green".

New comment by taolson in "The BeBox: BeOS Hardware, Photos, and the Apple Deal That Wasn't"

taolson — Wed, 13 May 2026 15:00:54 +0000

I remember a visit by Gasseé and a team of BeBox engineers to the PowerPC design center in Austin, where they demo'ed the yet-to-be released early version of the BeBox and OS. We were all duly impressed by the speed and responsiveness of the system. At one point they were demoing that it really was running multiple processors by opening a control panel that showed the processor activity, and clicking a button to disable one of the processors, which instantly doubled the load on the other processor. Someone in the crowd asked "What if you disable the other processor, too?", and they said "I don't know -- let's see." The system promptly crashed ;-)

New comment by taolson in "Sky – an Elm-inspired language that compiles to Go"

taolson — Mon, 06 Apr 2026 21:42:35 +0000

Sorry, I meant "Haskell / Miranda style syntax" -- e.g. curried functions, concise syntax with little boilerplate, etc. The word type is too overloaded ;-)

New comment by taolson in "Sky – an Elm-inspired language that compiles to Go"

taolson — Mon, 06 Apr 2026 21:01:44 +0000

Nice to see another language with Haskell / Miranda type syntax, but the vibe-coded implementation sure shows: e.g. src/Compiler/Infer.sky isUpperStart:

    isUpperStart : String -> Bool
    isUpperStart name =
        case String.slice 0 1 name of
            
            "A" ->
                True
            
            "B" ->
                True
            
            "C" ->
                True
        ... for 23 more cases.

And the corresponding go code in the bootstrap compiler is even worse.

New comment by taolson in "A case against currying"

taolson — Sun, 22 Mar 2026 18:13:32 +0000

An example where this is useful is to help inline otherwise recursive functions, by writing the function to take some useful parameters first, then return a recursive function which takes the remaining parameters. This allows the function to be partially in-lined, resulting in better performance due to the specialization on the first parameters. For example, foldr:

foldr f z = go

  where

    go [] = z

    go (x : xs) = f x (go xs)

when called with (+) and 0 can be inlined to

go xs = case xs of

    [] -> 0

    (x : xs) = x + go xs

which doesn't have to create a closure to pass around the function and zero value, and can subsequently inline (+), etc.

Show HN: Admiran: a pure, lazy functional language and self-hosting compiler

taolson — Sun, 08 Mar 2026 21:17:05 +0000

I wrote this over the past two years to explore how pure, lazy, functional languages like Haskell and Miranda are implemented and efficiently compiled. It has evolved into a fairly small (~7kloc) compiler written in itself, along with a library of pure, functional data structures. Even though the compiler is small enough to be read and understood by a single person, it implements:

* lazy lists, tuples, pattern matching, range and list comprehension syntax, algebraic data types, abstract data types, modules, user-defined value and type operators, etc.

* 19-pass compiler with whole-program compilation, inter-module inlining and optimizations, automatic derivation of comparison and show functions, module serialization / deserialization for caching module compiles

* Hindley-Milner type inference and checking

* Small runtime implements 2-generation compacting garbage collector

* Library includes implementations of map, set, bag, immutable and mutable vectors, functor/applicative/monad for maybe, either, state, and io types, parser combinators, etc.

If you are interested in pure functional programming languages, or want to have an interesting language for the next Advent Of Code season, it might be useful to you.

Comments URL: https://news.ycombinator.com/item?id=47301577

Points: 2

# Comments: 0

New comment by taolson in "Lil' Fun Langs"

taolson — Sat, 21 Feb 2026 12:44:09 +0000

Yes, the open-source release he did is what introduced me to Miranda. I rewrote a lot of my previous Haskell solutions to Advent of Code puzzles with it, and liked it so much I decided to try to improve on it ;-)

That's what led to Admiran. I originally wrote Admiran in Miranda, then bootstrapped from that to self-hosting when it was stable enough to do so. The original Miranda combinator compiler / interpreter took 20 minutes to compile all of Admiran, while the self-hosted version now takes 20 seconds.

One of the grad students of David Turner has taken up maintenance on the original Miranda source; the repository is now at https://codeberg.org/DATurner/miranda

New comment by taolson in "Lil' Fun Langs"

taolson — Fri, 20 Feb 2026 22:59:22 +0000

Don't know if my language is considered Lil' enough for this, but it's a pure, lazy functional language based upon Miranda (progenitor language to Haskell) that compiles to x86-64 asm. ~6700 SLOC for the (self-hosted!) compiler, and ~3300 SLOC additional for the extensive library of functional data structures and functions.

https://github.com/taolson/Admiran

New comment by taolson in "Lil' Fun Langs"

taolson — Fri, 20 Feb 2026 22:50:06 +0000

Either newt was already in the list, or it got added. We talked a bit about using our languages for AoC 2024 -- looks like you've been keeping busy working on it!

New comment by taolson in "Byte magazine artist Robert Tinney, who illustrated the birth of PCs, dies at 78"

taolson — Thu, 12 Feb 2026 16:28:44 +0000

The logo for Smalltalk-80, and later Squeak, came from the Robert Tinney cover of the Byte issue which introduced Smalltalk. The story behind it is documented here:

https://wiki.squeak.org/squeak/3459

New comment by taolson in "The WiFi only works when it's raining (2024)"

taolson — Fri, 30 Jan 2026 15:51:12 +0000

Also this one, which originally came from Usenet days:

https://old.reddit.com/r/talesfromtechsupport/comments/cp48t...

New comment by taolson in "Zen-C: Write like a high-level language, run like C"

taolson — Mon, 12 Jan 2026 20:49:37 +0000

The author includes some easter-eggs (printing random facts about Zen and various C constructs) which trigger randomly -- check out the file src/zen/zen_facts.c in the repository...

New comment by taolson in "Advent of Code 2025"

taolson — Sun, 30 Nov 2025 17:02:05 +0000

>I made my own, with a Haskell+Bash flavor and a REPL that reloads with each keystroke

That was impressive! Do you have a public repo with your language, anywhere?

New comment by taolson in "Advent of Code 2025"

taolson — Sun, 30 Nov 2025 16:17:57 +0000

Yes, there are some cool solutions using laziness that aren't immediately obvious. For example, in 2015 and 2024 there were problems involving circuits of gates that were elegantly solved using the Löb function:

https://github.com/quchen/articles/blob/master/loeb-moeb.md

New comment by taolson in "Advent of Code 2025"

taolson — Sun, 30 Nov 2025 16:09:33 +0000

AoC has been a highlight of the season for me since the beginning in 2015. I experimented with many languages over the years, zeroing in on Haskell, then Miranda as my language of choice. Finally, I decided to write my own language to do AoC, and created Admiran (based upon Miranda and other lazy, pure, functional languages) with its own self-hosted compiler and library of functional data structures that are useful in AoC puzzles:

https://github.com/taolson/Admiran https://github.com/taolson/advent-of-code

New comment by taolson in "Solving Fizz Buzz with Cosines"

taolson — Fri, 21 Nov 2025 22:58:21 +0000

Along that line, an over-engineered fizzBuzz using lazy list operations:

https://github.com/taolson/Admiran/blob/main/examples/fizzBu...

New comment by taolson in "Learn Prolog Now (2006)"

taolson — Wed, 12 Nov 2025 20:09:19 +0000

Prolog's constraint solving and unification are exactly what is required for solving type-checking constraints in a Hindley-Milner type system.

New comment by taolson in "What happened to Transmeta, the last big dotcom IPO"

taolson — Wed, 12 Nov 2025 15:17:30 +0000

>something AMD noted IIRC in the original K5 with its AMD29050-derived core

Just a small nitpick: I've seen the K5/29050 connection mentioned in a number of places, but the K5 was actually based upon an un-released superscalar 29K project called "Jaguar", not the 29050, which was a single-issue, in-order design.

New comment by taolson in "What Dynamic Typing Is For"

taolson — Sat, 18 Oct 2025 21:55:58 +0000

What about Miranda, Haskell, OCaml and F#?