News for hackers. Stuff that matters.
Re:Curry-Howard, the Ontological Ultimate by jerf on Wednesday October 15, 2014 @09:51AM (#8458375)
"But I do worry about the cognition overhead the syntax causes, and I do wonder if there is a "better way"."

I won't claim this is the full answer, but part of the better way is to simply cut away the syntax, revealing it to have been accidental complexity all along, and never a fundamental part of static typing. Even just working in a language with "auto" or "var" or whatever local construct creates a variable based on the type of the expression on the right without you having to puzzle it out yourself makes static typing go from an enormous pain to barely more work than dynamic typing.

I learned C++/Java in school in the 90s and spent most of the 200Xs in the dynamic world precisely because the paperwork of the static languages of the time were absurd. However, working with Go or a modern C# is totally different. (I haven't done C++ with "auto", so I can't add it myself, but others can speak to that.) In my opinion it makes static typing easy enough that it tips the balance back in favor of it; you put this tiny effort in and you get a ton back out.

Go's structural typing-ish automatically-satisfied interface is even easier; do you have a concrete class with some method you like, but need to be able to switch out the actual object with something else? Just declare the relevant interface, done. You can even after-the-fact "duck type" standard library code that you shouldn't directly modify under pretty much any circumstances with no hassle. The costs of the static type system are almost (but not quite!) eliminated, and in return you get, well, static type. Weak by P. Snively's standards, sure, but still better than nothing!

Haskell, of course, well, you fight with the static typer for a few weeks at first, but once you get good at Haskell (and I don't even mean "great", just good) you eventually get to the point where you discover the static type errors are fundamentally correct and trying to tell you something important, at which point you stop hating it for telling you how wrong you are and start loving it for telling you about a problem long before any other language would have. Personally I think everyone who considers themselves a professional programmer should clock at least six months with Haskell, not for any of the reasons you usually hear, but because it will teach you the rare skill of listening to your code. Static type systems, even the simpler ones such as Go or Java, aren't just slapping your hands because you've failed to satisfy their disconnected, academic ideals... they are saying things, and not just things like "you screwed up this method call" but very often things like "this design is fundamentally flawed, you've failed to account for how this value needs to be communicated to that function". It's important to get to the point that you understand this feedback as more than just the computer just being a computer.

This stuff often ends up explained in very academic language, but I have found it to be a brutally, brutally practical skill. And I write "real code" for things that do things on networks at scale, in the cloud, etc.

Re:Curry-Howard, the Ontological Ultimate by ufo on Wednesday October 15, 2014 @10:46AM (#8458656)
The nice thing about dynamic types is that they give you the expressive power to code things that would not be allowed (or at least not encouraged) in your type system, even though they might be allowed in a different type system. Back in the day, one notable example of this was parametric polymorphism: it comes "for free" in even the simplest dynamic language but took a while to become mainstream in static languages.

IMO, in an ideal world you would able to choose between dynamic and static verification of types depending on what your program is doing. This might even let us work with richer types than we do now! For example, most typed languages still do dynamic tests for array indexes because doing those statically requires dependent types (which are hard to use and not always worth the trouble). But if we had a language that lets us talk about the array lengths in the type system we would at least be able to give better error messages if something goes wrong, even if we only find out about it at runtime.

Re:Curry-Howard, the Ontological Ultimate by nl on Wednesday October 15, 2014 @10:48AM (#8458676)
I understand everything you are saying (didn't I make that clear in my original comment?). But I think you missed the point: I'm not arguing type systems aren't good. I think they are great. (re-reading - maybe I'm unfair on this. Your point about modern languages like Go and C# being better is a fair one)

I'm arguing that the single dimensional view the original article had on the speed of implementation vs correctness lacked some useful counter-perspectives. Infact, I think it was a pretty cheap shot, since it didn't recognize it as a critical tradeoff at all.

Go's structural typing-ish automatically-satisfied interface is even easier

Yes, I think the Go type system has some nice features.

Haskell, of course, well, you fight with the static typer for a few weeks at first

And that exactly the cognition overhead I'm talking about. Some productive programmers barely understand an if statement inside a loop. Using recursion is doubtful prospect.

I think the idea of people like that fighting a type system for weeks because it's good for them is completely unrealistic.

Note I'm not arguing that it isn't good for them: of course it is. And of course a type system "is telling you things". But people are writing real programs quicker without it.

I do like optional type systems. I think that some combination of optional type systems, test systems and tooling integration could lead to a system than slowly adds types to improve the reliability of programs, without the cognitive load that the traditional upfront typing workflow imposes.

But I'm just speculating about that.

I do know that untyped languages are often more useful that typed languages precisely because of the increased difficulty programming that type safety brings. I think that tradeoff is disappointing.

Re:Curry-Howard, the Ontological Ultimate by Dewie on Wednesday October 15, 2014 @10:15AM (#8458490)
> This stuff often ends up explained in very academic language,

What, that software should be correct according to the specification (either a formal one or an informal and implicit one)? Because that's the academic motivation I've found for things like type systems and program specification.

Re:Curry-Howard, the Ontological Ultimate by jerf on Wednesday October 15, 2014 @10:25AM (#8458550)
I mean like "Curry-Howard isomorphism" and "state space" and "monad" and such. It makes it very easy to dismiss as academic wankery, which is helped by the fact that, well, yeah, some of it is, honestly. But under that academic wankery is some brilliantly practical stuff that is hard to learn from the communities that are over-focused on "practicality".
Re:Curry-Howard, the Ontological Ultimate by Dewie on Wednesday October 15, 2014 @05:26PM (#8461875)
> I mean like "Curry-Howard isomorphism" and "state space" and "monad" and such.

What's the problem with those?