Five examples

[-]25Hour5y130

I like type checkers less because they help me avoid errors, and more for ergonomics. In particular, autocomplete-- I feel I code much, much faster when I don't have to look up APIs for any libraries I'm using; instead, I just type something that seems like should work and autocomplete gives me a list of sensible options, one of which I generally pick. (Also true when it comes to APIs I've written myself.) I'm working on a Unity project right now where this comes in handy-- I can ask "what operations does this specific field of TMPro.TextMeshProUGUI support", and get an answer in a half a second without leaving the editor.

More concretely than that, static typing enables extremely useful refactoring patterns, like:

Delete a method or change its return type. Find everywhere this breaks. Fix the breakages. Now you're pretty much done; in a dynamically-typed language you're reliant on the unit test suite to catch these breakages for you. (All the places I've worked have done unit tests, but generally not above somewhere around 80% coverage; not enough to feel entirely safe performing this operation.)
Refactor/rename becomes possible, even for methods with possibly-duplicated names across your files. For instance: renaming a method named "act" on a class you've implemented requires manual effort and can be error-prone in Javascript, but is instantaneous in C#. This means you can use refactor/rename compulsively any time you feel you have come up with a better name for a concept you're coding up.

I kind of agree with the article posted that, in general, the kinds of things you want to demonstrate about your program mostly cannot be demonstrated with static typing. (Not always true-- see Parse, don’t validate (lexi-lambda.github.io) -- but true most of the time.)

[-]Adam Zerner5y70

Thank you for those thoughts, they're helpful.

I actually was aware of the autocomplete benefit before. I've only spent about three months using a staticly typed language (TypeScript). In that time I found myself not using autocomplete too much for whatever reason, but I suspect that this is more the exception than the rule, that autocomplete is usually something that people find useful.
I wasn't aware of those benefits for refactoring! That's so awesome! If it's actually as straightforward as you're saying it is, then I see that as a huge benefit of static typing, enough where my current position is now that you'd be leaving a lot on the table if you don't use a staticly typed language for all but the smallest of projects.

At work we actually decided, in part due to my pushing for it, to use JavaScript instead of TypeScript for our AWS Lambda functions. Those actually seem to be a time when you can depend on the codebase being small enough where static typing probably isn't worth it.

Anyway, important question: were you exaggerating at all about the refactoring points?

[-]25Hour5y30

No. I compulsively use the refactor/rename operation (cntrl-shift-r in my own Visual Studio setup) probably 4 or 5 times in a given coding session on my personal Unity project, and trust that all the call sites got fixed automatically. I think this has the downstream effect of having things become a lot more intelligible as my code grows and I start forgetting how particular methods that I wrote work under-the-hood.

Find-all-usages is also extremely important when I'm at work; just a couple weeks ago I was changing some authentication logic for a database we used, and needed to see which systems were using it so I could verify they all still worked after the change. So I just right-click and find-usages and I can immediately evaluate everywhere I need to fix.

As an aside, I suspect a lot of the critiques of statically-typed languages come from people whose static typing experiences come from C++ and Java, where the compiler isn't quite smart enough to infer most things you care about so you have to repeat a whole bunch of information over and over. These issues are greatly mitigated in more modern languages, like C# (for .NET) and Kotlin (for the JVM), both of which I'm very fond of. Also: I haven't programmed in Java for like three years, so it's possible it has improved since I touched it last.

Full disclosure: pretty much all my experiences the last few years have been of statically-typed languages, and my knowledge of the current dynamic language landscape is pretty sparse. All I can say is that if the dynamic language camp has found solutions to the refactor/rename and find-all-usages problems I mentioned, I am not aware of them.

You can get some of these benefits from optional/gradual typing systems, like with Typescript; the only thing is that if it's not getting used everywhere you get a situation where such refactorings go from 100% to 90% safe, which is still pretty huge for discouraging refactoring in a beware-trivial-inconveniences sense.

[-]Viliam5y50

I compulsively use the refactor/rename operation (cntrl-shift-r in my own Visual Studio setup) probably 4 or 5 times in a given coding session on my personal Unity project, and trust that all the call sites got fixed automatically.

Similar here. I use renaming less frequently, but I consider it extremely important to have a tool that allows me to automatically rename X to Y without also renaming unrelated things that also happen to be called X.

With static typing, a good IDE can understand that method "doSomething" of class "Foo" is different from method "doSomething" of class "Bar". So I can have automatically renamed one (at the place it is declared, and at all places it is called) without accidentally renaming the other. I can automatically change the order of parameters in one without changing the other.

It is like having two people called John, but you point your cursor at one of them, and the IDE understands you mean that one... instead of simply doing textual "Search/Replace" on your source code.

I have never had a static type checker (regardless of how sophisticated it is) help me prevent anything more than an obvious error (which should be caught in testing anyway).

In other words, every static type declaration is a unit test you didn't have to write... that is, assuming we are talking about automated testing here; are we?

I agree that when you are writing new code, you rarely make type mistakes, and you likely catch them immediately when you run the program. But if you use a library written by someone else, and it does something wrong, it can be hard to find out what exactly went wrong. Suppose the first method calls the second method with a string argument, the second method does something and then passes the argument to the third method, et cetera, and the tenth method throws an error because the argument is not an integer. Uhm, what now? Was it supposed to be a string or an integer when it was passed to the third or to the fifth method? No one knows. In theory, the methods should be documented and have unit tests, but in practice... I suspect that complaining about having to declare types correlates positively with complaining about having to write documentation. "My code is self-documenting" is how the illusion of transparency feels from inside for a software developer.

I mostly use Java, and yes it is verbose as hell, much of which is needless. (There are attempts to make it somewhat less painful: Lombok, var.) But static typing allows IDE to give me all kinds of support, while in dynamically typed languages it would be like "well, this variable could contain anything, who knows", or perhaps "this function obviously expects to receive an associative array as an argument, and if you spend 15 minutes debugging, you might find out which keys that array is supposed to have". In Java, you immediately see that the value is supposed to be e.g. of type "Foo" which contains integer values called "m" and "n", and a string value called "format", whatever that may mean. Now you could e.g. click on their getters and setters, and find all places in the program where the value is assigned or read (as opposed to all places in the program where something else called "m", "n", or "format" is used). That is a good start.

[-]Adam Zerner5y20

It is like having two people called John, but you point your cursor at one of them, and the IDE understands you mean that one... instead of simply doing textual "Search/Replace" on your source code.

Thanks for explaining this. I had been planning on investigating how it compares to search and replace, but I think this clarified a lot for me.

And thank you for the rest of your thoughts too. I think my lack of experience with static typing is making it hard for me to fully grok them, but I am groking them to some extent, and they do give me the vibe of being correct.

[-]Adam Zerner5y20

Good to know. Thanks!

[-]philh5y40

More on type checking:

A thing I did recently while working on my compiler was write a "macroexpand" function that wasn't recursive. It macroexpanded once, but didn't macroexpand the result. I think I was like "whatever, I'll come back later and handle that", and maybe I would have done. But shortly afterwards I made the types more specific, using mildly advanced features of Haskell, and now the macroexpand function claimed to return a "thing that has been fully macroexpanded" but in code was returning a "thing containing something that hasn't been macroexpanded". I might have caught this easily anyway, but at minimum I think it would have been harder to track down.

So when the author says "I carry around invariants (which is a fancy name for properties about things in my program) in my head all the time. Only one of those invariants is its type", my reaction is that he probably could put more invariants in the type. Examples of that: you can put "this can't be null" into the type, or more precisely the thing can't be null by default but you can choose to relax that invariant in the type. You can put "this function may only be called from within a transaction of isolation level no weaker than repeatable read" into a type, we've done that at work. You can put "this array has a known length" into a type, and "this function returns an array of the same length it was passed", though I haven't found those useful myself. Similarly "this hash table definitely has a value for key X" and "this function returns a hash table with exactly the same keys". "This list is nonempty" is a type-level invariant I use a lot. You even could put "this is an increasing list of floats with mean X and standard deviation Y" into a type, modulo floating point comparison problems, though I'm not convinced that's a realistic example.

I've also had a lot of cases where I have a type with a limited set of possible values, then I add a new possible value, and all the places that accept the type but don't handle the value complain. This isn't strictly type checking, it's exhaustiveness checking, but I'm not sure you can get it without type checking. Maybe easy to catch through testing for functions that accept the type as input (as long as you have e.g. a random generator for the type, and add this case to it), but I think harder to catch when you call functions that return the type.

So I speculate static typing is more useful the more your domain types can be usefully modeled as tagged unions. If all your types are just "a field for this value, a field for that value, ...", where none of the values depend on the others, the kind of thing modeled by C structs or Python classes or Haskell records, it will mostly catch obvious errors. But if you find yourself writing things like that but with lots of invariants like "foo is true, then bar will be null and baz won't be", then that's a good fit for a tagged union, and you can move that invariant out of your head and into the type checker and exhaustiveness checker.

(There's a related thing that we don't have, I guess I'd call co-exhaustiveness checking. Consider: "I have a random generator for values of this type, if I add a new possibility for the type how do I make sure the generator stays in sync?" Or "how do I check the function parsing it from strings has a way to parse the new value?")

(Also, if the author's never had to spend a long time tracking down "this function should never be called with a null input but somehow it is, wtf is going on"... more power to him, I guess.)

[-]Adam Zerner5y40

Great points. I see how making your types more specific/complicated helps you catch bugs, and the example with your compiler really helped me to see that. However, making types more complex also has a larger upfront cost. It requires more thought from you. I don't have a good intuition for which side of the tradeoff is stronger though.

[-]crl8265y40

2) If you’re not feeling “hell yeah!” then say no

I've thought a lot about this myself.

I think the first thing you have to stipulate is that this helps when deciding on goals, not necessarily the things you have to do to get the goal. You may be "hell yeah" about traveling the world, but not "hell yeah" about packing. That doesn't mean you shouldn't travel the world. I don't think Derek was arguing for this level of decision making.

If you buy that, I think the key is that it only works when you have a lot of slack. Derek Sivers is and has been independently wealthy and has way way more options than most people do. It's a very good sorting move in that situation. If you have few options, you probably can't use this as universally as he suggests.

[-]Adam Zerner5y10

Yeah those caveats make a lot of sense. However, I strongly suspect that they're not exhaustive. Not that you're implying they are, but it's important to note because when you acknowledge that they're not exhaustive, you rightly treat this sort of advice as more of a heuristic than a rule.

[-]crl8265y10

Sure. I'd love to hear what other caveats you think are important.

[-]Adam Zerner5y10

None come to mind right now. But the thing is, that probably just means I can't think of them as opposed to them not existing.

[-]Brendan Long5y40

I really need to pay attention so I can give examples of why I like type checkers, but it's always hard to remember in the moment. I'm not sure how to remind myself to do it but I'll make a note to try to watch for this for a few days.

[-]Adam Zerner5y30

That would be great! And is a great example of how coming up with examples is often difficult.

[-]bfinn4y30

Philosophy thrives on carefully-chosen examples, which are thought experiments - i.e. that illustrate relevant aspects, and hopefully exclude irrelevant confusing aspects; they are also often tricky (e.g. extreme or borderline) cases. Test cases in law are similar.

[-]Adam Zerner4y20

Ah, I never made that connection before. Great point!

[-]bfinn4y10

Re 'hell yeah', I tend to roll my eyes at such advice from self-help gurus, because for example, not many people can find jobs they can go 'hell yeah' at. Hell yeah they'd like to be a rock star or film star or astronaut, but they're only capable of humdrum work, or they train as a musician/actor and find there's almost no paid work. (So then the self-help gurus tell them that if they'd only adopt the right positive attitude they'd say 'hell yeah' to shelf-stacking - rather than just accept that life is a mixed bag and we have to do some things we don't like much.)

The weak form is better, viz. if you think of something you can say 'hell yeah' to that's actually feasible, then do it. I.e. say yes to 'hell yeah', rather than say no to not-'hell yeah'.

LESSWRONG
LW

LESSWRONG
LW

42

42

42

1) Your Cheerful Price

2) If you’re not feeling “hell yeah!” then say no

3) Why I Still ‘Lisp’ (and You Should Too)

4) Short Fat Engineers Are Undervalued

5) Embedded Interactive Predictions on LessWrong

Hat tips

It's not easy