I guess that has something to do with syntax. When I switch between Delphi and Visual Basic (aaaargh!) at work, I have problems with their similar syntax. For example, I keep using semicolons in VB. But I think programmers can benefit from such switching because it forces them to look at problems from different angles and that helps them to evolve their skills. However, I believe minimalists syntax help more because they can be used in their entirety without context switching within the same language.

[ It seems that we had really cool (Lisp, Smalltalk) development environments in the past, and today's environments are relatively dumb. Are we really going to move in the direction of smarter environments?

Languages that rely on a development environment have a harder time becoming successful because they're typically only accessible on one platform. Languages that only rely on text editors are usable just about everywhere. ]

Well, as I wrote in the post, I think a good environment is helps a lot. Smalltalk showed that, and it also showed that you can have a good environment in multiple platforms if the language is open. I believe the problems is that people today are just too used to using glorified text editors and don’t worry too much about good environments. Nonetheless, every time a good environment is created for a given language people realize they’re much more productive if the environment is more powerful. Delphi, for example, has many components that integrate directly in its IDE to help programmers to be more productive. One of such components is Bold, a model-driven architecture tool that allow the problem domain of the application to be mapped to classes that seamlessly access the database. You can code everything by hand, but it will take much time to do so. Also, people are always trying to create extensible editors that tightly integrate with the languages they support. That’s especially true of Java, PHP, Perl and Python. I think that also demonstrates that good environments will be much more successful in the future.

[ Extending classes defined elsewhere sounds cool. What worries me is that an application takes on a life of its own, in its own little world. If I want to send you something of mine, I have to ship you my entire Squeak world. I can't just send you my class, because it depends on Integer having been modified in some way, maybe using my own Logging or Exception framework. I ran into this problem on LambdaMOO, where objects defined on one MOO could not be used on another MOO because the basic types (person, room, etc.) were different. Customization and reuse leads to dependencies. Dependencies make it harder to extract something to reuse it elsewhere. ]

Well, Smalltalk deals nicely with this problem. The environment keeps track of what has been changed, and you can send just what was modified. And, in practice, you rarely have confliting changes in different projects as many of those changes do not modify the base behavior of the classes. Of course, you can still have problems — especially when you are modifying classes in the problem domain. However, those problems can happen in any kind of project. For example, changes in the implementation of interfaces in a Java project can cause the same kind of trouble. Also, Smalltalkers tend to program in small and independent pieces and I guess that also helps avoiding problems.

Sometimes having N simple but very different things is easier for my brain to deal with than having 1 thing that can do it all. I can deal with C and Scheme and Python all at the same time because they’re so different. I have trouble dealing with C and C++ at the same time, or Scheme and Lisp at the same time.

It seems that we had really cool (Lisp, Smalltalk) development environments in the past, and today’s environments are relatively dumb. Are we really going to move in the direction of smarter environments?

Languages that rely on a development environment have a harder time becoming successful because they’re typically only accessible on one platform. Languages that only rely on text editors are usable just about everywhere.

Extending classes defined elsewhere sounds cool. What worries me is that an application takes on a life of its own, in its own little world. If I want to send you something of mine, I have to ship you my entire Squeak world. I can’t just send you my class, because it depends on Integer having been modified in some way, maybe using my own Logging or Exception framework. I ran into this problem on LambdaMOO, where objects defined on one MOO could not be used on another MOO because the basic types (person, room, etc.) were different. Customization and reuse leads to dependencies. Dependencies make it harder to extract something to reuse it elsewhere.