On Smalltalk

I think haskell should be added to the list. I've started learning it recently and find it easier to pick up than lisp, at the same time its just as powerful in my opinion.

I think the view on the staticly typed languages is really a surface look.

Haskell and many other modern staticly typed languages let you define your own abstractions even without having macros nor objects. Nemerle even goes all the way down to add macros (hygienic and not) to the language, and Scala allows you to define your own control structures without macros by using type informations.

But in the end I agree with the post spirit :)

Would you feel better if I said manifestly typed instead? It's more what I meant.

I've heard Haskell mentioned a few times now, I'll have to check it out.

hmm, I am on mac and I cant see the screencast in vlc or quicktime. can you make a new one?

Articles like these bother me outside of the technology itself. It's obvious who you are targeting with statements like "treadmill in front the tv.", and there's really no meat to it. Replace Smalltalk here with Ruby and we have a typical Rails post for example.

In an honest question, if you knew you had an application that would live in some form, for 10 years, every three years being operated on by 5-7 different people, would you choose Smalltalk for the job instead of Php/Perl/Ruby/Java/C#, and why?

That's the real test.

Ivan, I never said any such thing, that comment was from Dave's article, which I was linking to.

Would I choose Smalltalk, absolutely. Smalltalk's been around far longer than any other language you just mentioned, so 10 years doesn't mean anything.

There's no shortage of willing Smalltalk programmers, just a shortage of companies willing to use it, out of needless fear. Programming in Smalltalk is vastly superior to programming in any of those languages, and half of them, are just bad copies of Smalltalk, so why not use the original?

I'm a god therefor I should start learning Smalltalk....

I don't know this language but for now I'm happy with Java and all the free libraries I find.

RE: Ivan's post: "..if you knew you had an application that would live in some form, for 10 years, every three years being operated on by 5-7 different people, would you choose Smalltalk for the job instead of PHP/Perl/Ruby/Java/C#, and why?"

Interestingly, Smalltalk has probably changed less over much more than 5-7 years than the languages mentioned (except perhaps Perl).

I got started in Smalltalk in 1994. I developed a prototype for one of our clients, the tools were not as sophisticated as they are today but the experience was enjoyable for me. I was fascinated and I literally fell in love with this language. Unfortunately there were less projects using Smalltalk than Java and C++ and I was disconnected for a while. It is unfortunate that corporations didn't embrace Smalltalk as they did for Java/j2ee and .NET technologies. Now I am playing with a non commercial license of VW on my computer at home, I am still fascinated by the power of this language, especially with all the goodies available. I think Smalltalk will be revived and will get its share of development market. The future will rely on developing very sophisticated frameworks that abstract and hide the complexities for the mainstream developer/user (web, BI, ORM, RCA, etc... to name a phew). Users do not need to know that an app was developed using smalltalk. Also Smalltalk needs to keep up and provide the same technologies and framework as the other languages. Long live Smalltalk :-)

Forth has also often been praised for its amplifier nature. And you may want to have a look at Factor (http://factorcode.org/), which mixes the all-reflexive nature of Smalltalk with the stack-oriented characteristics of Forth.

"Programming in Smalltalk is vastly superior to programming in any of those languages"

Nice argument, that. Of course you must know that programming in Lisp is vastly superior to programming in Smalltalk.

", and half of them, are just bad copies of Smalltalk, so why not use the original?"

Thank goodness this kind of nonsensical advice isn't taken: we'd still be driving around in Model T's.

Actually, it's not, while the Lisp language is strictly more powerful, the Lisp environment isn't, unless you have a Lisp machine, which is basically what a Smalltalk image is.

As for the Model T, no, there's nothing wrong with progress, modern car's aren't "bad" copies, they're better copies. Popular modern languages however, haven't bested Smalltalk yet.

Actually, modern cars are better only superficially. The gasoline engines in our cars STILL only gets 15% to 20% fuel efficiency -- precisely the same efficiencies as the Model T. The only thing that makes them "better" are the amenities and the catalytic converters. Therefore, in a very real sense, yes, we actually STILL ARE driving around in Model Ts. Only, they're heavier now, and thus, actually consume more fuel.

A car built by George Constantinesco ( http://fluid.power.net/fpn/const/const005.html) got an impressive 100MPG by using a rediculously tiny engine coupled with his (at the time) patented torque converter. Granted, the car didn't exceed 40MPH. But, I have to admit, I think I've brought my car up to 55MPH only 3 times in the past six months, let alone faster. This just goes to show you that people value vanity over utility.

So it is with programming languages. Lisp/Scheme, Smalltalk, Forth/Joy, Haskell -- the four purest of the purest languages/families in existance. All of them brutally utilitarian. None of them slated to become grand slams.

Haskell has the same bubble of popularity that Smalltalk did back in the early 80s, because it's pushing all the new buzzwords (typeclasses, lazy evaluation, monads, etc.). Once other languages catch on to Haskell's techniques, I predict it will fall back into relative obscurity, to be replaced by something else (also functional, but just not as pure). To a limited extent, OCaml is already doing this with Haskell, especially since it's compiled code runs substantially faster than Haskell code with far less programmer effort.

Sure, if you only define "better" by gas mileage, most people however, would include things like comfort, speed, conveniences like air conditioning, cruise control, anti-lock brakes, and all the other things that make modern cars "vastly" superior to the model T.

Most modern languages however, are overly complex for no good reason and very little if any benefit. Programming is a form of math where simpler and more elegant is better. For all the "features" of modern languages, they still can't do things trivially done in Smalltalk or Lisp, they're too focused on preventing the programming from doing things than on enabling the programmer to do things.

Things like Lisp, Haskell, and Smalltalk remain unpopular not because they're inferior or utilitarian, but because they're hard to make money off of and require skilled minds to operate (small market). It's much more profitable to push inferior languages tools that require great tool support from vendors (cha ching) and enable mediocre minds to muddle through (huge market) than it is to push better languages that just work.

There comes a time when you begin to understand Lisp enough to appreciate it's incredible nature and beauty. I know no other language that has given me the thrill that lisp has. and although I'm still a long way from being an expert I've written enough code for a large enough project to realize that lisp will always be my favorite language....so maybe it's not about comparing cars, but fine wine or music....