That is an interesting observation. I started out low level in 8 bit land. To me, units broke down to whatever close representation fit into 8 maybe 16 bits... But, you are right! A BASIC with units would have been quite useful back then.

Would have caught a fair number of my bonehead errors.

Later, moving to C and various scripting languages, I just sort of kept doing the same thing. Work units out old school, then comment whatever equations made sense in the program, and then do math, deciding on fixed or floating point depending...

I will have to give Julia a look. Seems intriguing.

You should check out Frink, a delightful unit-preserving calculator and language optimized for (but not limited to) back-of-the-envelope calculation.

Yes, it has implicit multiplication! :) It also offers exact rational fractions, transparent bigint conversion, and plus/minus intervals that automatically tracks error bars through all arithmetic operations.

Docs: https://futureboy.us/frinkdocs

Online REPL: https://futureboy.us/fsp/frink.fsp?fromVal=1+furlong+%2F+for...

[Unexpectedly humorous] units data file: https://futureboy.us/frinkdata/units.txt

I am well aware of Frink, and glad you mentioned it!

Julia has the advantage that you can do things with it that aren't unitful calculations, a classic 80% solution. Frink has the advantage that, well... it's Frink. Really nothing else like it.

Awesome! I admit I'm a bit confused though: Frink doesn't force you to use units (you could ignore them if you wanted, and even skip loading the built-in units on startup), so I'm not sure where the advantage is.

Were you thinking of a specific feature set in Julia that's lacking in Frink? Thanks.

What I meant is that Julia is a general purpose programming language, and Frink is a comprehensive and thorough calculation DSL.

You could use Frink for things that aren't its focus, of course. But few would want to.

I am not well aware. Thanks and just another reason why I love this little place on the web.

I have built my own implementations of units in a couple of functional languages (Haskell and Ocaml) using shadow types. How this pattern works is you tag a numeric type with an extra algebraic type defining the units and then define how the arithmetic operators handle the units. The cool thing about doing it this way is the shadow types compile away so there is zero runtime cost but you can assert and pattern match on the types and put them in your unit tests etc and your code literally won't compile if you mess the units up in some way.