Seeing types where others don't

26 points by eatonphil

This was a really fun (and unexpected!) article. Re: the final takeaway:

If you would like to take anything away from this article, I believe it should be that we are nowhere near the full potential of leveraging types in our languages, we’re leaving too much on the table

If you look at the errors emitted by databases when you have type errors, sometimes one needs a fair bit of head-scratching to figure things out. And databases have so many more users compared to (even popular) tools like jq.

So yeah, I've definitely felt the same sentiment that the author is echoing.

shapr

The program jq was originally written in Haskell, would it help to look at the original and see how the types fit?

alpaylan
Ah, very interesting, I didn't know that. I found the original commit (https://github.com/jqlang/jq/commit/eca89acee00faf6e9ef55d84780e6eeddf225e5c) which uses JSValue from Text.JSON:
```
data JSValue
    = JSNull
    | JSBool     !Bool
    | JSRational Bool{-as Float?-} !Rational
    | JSString   JSString
    | JSArray    [JSValue]
    | JSObject   (JSObject JSValue)
    deriving (Show, Read, Eq, Ord, Typeable)
```
Unfortunately I think the current implementation has diverged into its own quirky type system, so we wouldn't be able to leverage the Haskell version. However, Michael Färber (who wrote jaq) has been working on a formal semantics for jq (https://arxiv.org/abs/2403.20132) which can guide the work further. It's important to note that doing so still requires retrofitting formalization on top of jq, so you still have to play an exploratory role as the person doing the formalization, for instance when looking into the paper I had found a negligible bug (https://github.com/01mf02/jq-lang-spec/issues/3) that was later fixed.

koala

My variant of this is "your database may be schemaless, but your data definitely has a schema".

To me it's pretty "clear" that types have a cost that only is a net positive beyond a certain size. But I think the evidence is thin...

(My favorite language is bash, because I think it's the language that does its thing better than any other language does its. However, its thing is writing one liners, which I do frequently, but it's not all I do.)

lilac

I think there’s a valuable lesson in here about teaching programming to people. I see so much beginner programming material brush off types, refusing to acknowledge them, as if they’re some shameful bit of programming that deserves no love.

but when you pass around a string in python, python still knows it’s a string. every single value still has a type. you’re not doing beginners some great big favor by removing complexity from the equation until they’re “ready for it”. you’re just sweeping it under the rug and lying to them about. you are depriving them of a helpful tool to shape their learning and provide deeper meaning into what the computer is doing.