Hacker News: taolson

New comment by taolson in "Types of types: Haskell's Kind system"

taolson — Sun, 18 Oct 2026 12:20:48 +0000

Agreed. But there's a big difference between parametric polymorphism (List) and ad-hoc polymorphism like typeclasses. It would be very painful to have to write a new list type for any kind of value type it might hold, but with monads you have many fewer distinct implementations (mainly just Maybe / Either / List / State / IO) and their actions are so different that you almost have to know exactly which monad you are using in the code, so "generic" code that can operate with any monad is less useful.

New comment by taolson in "Types of types: Haskell's Kind system"

taolson — Sat, 17 Oct 2026 23:29:50 +0000

That may be true for functions which operate on a generic Monad typeclass, but typeclasses (Higher kinded types) aren't required to implement concrete Functor / Applicative / Monad instances for a particular type, e.g. Maybe:

    fmap f Nothing = Nothing
    fmap f (Just x) = Just (f x)

    pure x = Just x

    Nothing >>= f = Nothing
    Just x >>= f = f x

New comment by taolson in "Yet another way to invoke functions without parentheses"

taolson — Fri, 16 Oct 2026 16:34:03 +0000

In a lazy language like Haskell, the order in which things are actually evaluated is f -> g -> h -> x, because arguments to a function are only evaluated when the are needed, rather than before they are called. But even so, I still prefer writing it as x |> h |> g |> f.

New comment by taolson in "Push ifs up and fors down: The idiom, its algebra, and its limits"

taolson — Wed, 07 Oct 2026 21:57:51 +0000

Or just use lazy list operations with a single if test at the end:

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

New comment by taolson in "Saab has unveiled its A3 collaborative combat aircraft concept"

taolson — Tue, 01 Sep 2026 18:07:23 +0000

Yes, that's an even better picture! Austrian air-force version, right?

New comment by taolson in "Saab has unveiled its A3 collaborative combat aircraft concept"

taolson — Tue, 01 Sep 2026 17:32:53 +0000

I still consider the Saab Draken one of the most beautiful aircraft ever designed:

https://en.wikipedia.org/wiki/Saab_35_Draken

Especially the top view:

https://www.flyajetfighter.com/wp-content/uploads/2025/09/Sa...

New comment by taolson in "Jolt: Clojure compiler implemented with Chez Scheme"

taolson — Tue, 11 Aug 2026 17:44:55 +0000

You're probably thinking of Ian Piumarta's COLA project (Combined Object Lambda Architecture), which had parts named after cola soft-drinks (Coke was a lisp-like language, Pepsi was a Smalltalk-like language, and Jolt was an early implementation of Coke):

https://www.piumarta.com/software/cola/

New comment by taolson in "Squeak 6.1"

taolson — Mon, 10 Aug 2026 18:18:02 +0000

Congrats to the Squeak 6.1 team! I was an early contributor to Squeak from when Alan Kay's group was at Apple (I see that SameGame, the first game implemented in Morphic is still in the image), and still enjoy following the progress of Squeak and all of its spinoffs.

New comment by taolson in "Show HN: Wyzer Programming Language"

taolson — Fri, 07 Aug 2026 16:32:05 +0000

Since your language is very "rust-like", what made you choose Ocaml as the implementation language?

New comment by taolson in "Unearthing my 1996 windowed OS in machine code for Am29000 homebrew computer"

taolson — Thu, 06 Aug 2026 19:14:33 +0000

The FPU in the 29050 was based on the Am29325 bit-slice family FPU; an extra write port was added to the register file to allow for asynchronous FPU result writeback, which allowed the parallel operation.

gr2 and gr3 were used in the 29050 for FP condition code registers, but otherwise I'm pretty sure accessing the rest caused a trap.

New comment by taolson in "Unearthing my 1996 windowed OS in machine code for Am29000 homebrew computer"

taolson — Thu, 06 Aug 2026 17:54:41 +0000

The registers could also be partitioned into fixed sizes and protected, to allow for a banked register file that allowed for amazingly fast context switches in RTOS systems.

New comment by taolson in "Unearthing my 1996 windowed OS in machine code for Am29000 homebrew computer"

taolson — Thu, 06 Aug 2026 16:34:54 +0000

> Well that was basically an am29000 but with an x86 instruction decoder front end.

The K5 was based upon a 29K-family design, but it was actually an un-released superscalar project code-named "Jaguar", rather than just a 29K with an x86 decoder.

New comment by taolson in "Unearthing my 1996 windowed OS in machine code for Am29000 homebrew computer"

taolson — Thu, 06 Aug 2026 16:01:35 +0000

Yep, it wound up as the main CPU in a bunch of laser-printers, as well as Apple's 8*24GC QuickDraw accelerator card for the Macintosh, and as part of the flight-control computer on Boeing 777s, among many other embedded system designs.

New comment by taolson in "Unearthing my 1996 windowed OS in machine code for Am29000 homebrew computer"

taolson — Thu, 06 Aug 2026 14:24:22 +0000

Wow, blast from the past! I was on the architecture / micro-architecture team for the 29K and 29050, and your story of writing and debugging the emulator brought up similar memories of working on the performance simulator for these chips.

Very impressive work -- congratulations!

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.