I’m proposing that we steal their good ideas (type theory) but get rid of the languages that force you to do a big design up front by refusing to run code that only 50% works.

I’d like the benefits of SML and Haskell typing, combined with the loosey-goosey “code it up right now and then refine each level as you go” style of Python and Perl and Ruby and Lisp. This is the best way I can think of getting those.

Unit tests are nice, and they help a lot, but guarantees about code that are backed up by theory are really nice as well. If we could combine rapid application development and unit tests with strong typing, then I think it could be a huge win.

The way I tend to develop systems is I write a halfass hack, and then I extend and change and refactor it into something even biugger and better. So my ideas start out wispy and thin, but as I go they get more and more concrete. A nice type system could really be a helpful solidifier for that concrete, as long as it didn’t force me to pour concrete for my first pass through the problem.

in addition, with static type checking you lose the late-binding nature, don’t you? alan kay would hate you. of course, he’s unemployed right now, so what does he know?

The system I’m also envisioning, would, for each chunk of code, spit out ‘known to break’, ‘known to be safe’, ‘maybe safe, depending on X’, or ‘uncheckable’.

Also, while I really like late binding and Alan Kay’s ideas, systems tend to ossify and harden over time. They get too many dependencies to be effectively changeable. So, in reflection of this fact, it would be nice if we could harden the underlying code via type safety guarantees.

But for system development, late binding and loosey-goosey types are where it’s at. I just think it’s unfortunate that people tend to write their prototypes and their final products in different languages. There could be a big win if we could provide a gradual transition from the development speed and flexibility of the first to the safety of the second.

Type safety provides a bunch of guarantees beyond those provided by unit tests, and does so in a programmatic way that compilers and interpreters can take advantage of. So this gradual transition from the loosey-goosey system should also be a gradual transition from a slower system to a speedier system.

Much like people saying that “speed is a feature – add it in at the end if it’s required”, I think this should be expanded to “type safety is a feature – add it in at the end if it’s required”.

if you want to stick with python, don’t decorators provide something of that nature?