I’ve been looking at Smalltalk (VisualWorks) for the past couple of months - and the more I learn the more I’m impressed. However, I think I must be missing something as Smalltalk doesn’t seem to be popular these days - and perhaps it never was.
What do the people who have dropped Smalltalk in favor of Java, C++, Ruby, etc. know that I don’t or in other words “Why isn’t Smalltalk more popular?”
Smalltalk lacks the vendor support that Java and C# have (think of that in terms of the companies selling their wares), and the coolness factor that Ruby/Python/etc have.
Maybe Alan Kay will pop in and tell us his reasoning.
It differs too much syntactically and conceptually from languages like C.
Switching from a C-like language to Smalltalk might seem too difficult to many people, given that many students and hobbyists grow up learning C-like languages (C, C++, Java, PHP, etc.).
Lots of reasons, some of which are:
Having said that, I use Smalltalk (Squeak) myself, and enjoy knocking up GUI ideas and tools using it - but only for personal entertainment.
Update as of 29-Jul-2010: Having said all the above, which I stand by, the latest version of Squeak (4.1) is a vast improvement in terms of look-and-feel and performance. It is also MIT licensed, if that matters to you. well worth a look if you are at all interested in Smalltalk,
Let's compare smalltalk with Java to see what went wrong.
Timing. Virtual machines are expensive in terms of speed and memory consuption. When Smalltalk appeared, we were "not there" yet. Smalltalk was a heavy load and it was very difficult to use. Computers were not so as wide-spread as today. Java, on the other side, got in the market "just in time" for a amazing growth of CPU and memory in a already ubiquitous PC.
There was freedom. Smalltalk was about "take it all or leave it all". Java is a language, that can be used in different environments.
Syntax also plays a role. Although Smalltalk is pure OO and beautiful, it is easier for a programmer to learn Java.
There was this module I had in Uni, was called something like Programming Languages, Client-server computing and Concurrency. A certain part of this module was dedicated, as its name indicates, to Programming Languages in general. Smalltalk was mentioned about as much as Algol 60. And you wonder why no-one wants to go the SmallTalk way?
I believe the influence of Higher Education institutions is greater than one would think. We are talking about masses of software engineers/computer scientists/etc... leaving Uni's every year with a Java-centric mental model.
No doubt a controversial answer, and definitely a personal one, but... I don't like zealots.
Most of the Smalltalkers that I've run into on the net try to say how Smalltalk is basically the best thing since sliced bread, and how awful every other language is. I'm not saying that all Smalltalkers act that way - but it's been a very noticeable trend in the ones I've encountered. They've very clearly been looking down on anyone who doesn't use Smalltalk.
That's simply not a good way of persuading people to use a language. It puts me off because I enjoy learning with a community, and I don't really want to be part of a community which looks down on me - even if it's just a vocal minority taking that attitude.
I don't know enough about Smalltalk to comment on it technically at all - and I'd really like to learn it "some day"... but it's lower down the list of languages for me to learn than others where I've had a more positive experience with the community. (F# nearly had the same problem for me, due to someone taking that attitude in the C# newsgroup, but fortunately more engaging personalities have prevailed.) The fact that people do like it so much suggests there are good things about it as a technology - but realistically, I'm a human being rather than a computer. Technical merit is only part of the picture.
Maybe I'm just alone on this, but in general: if you want to show someone how awesome your favourite thing is, and maybe persuade them that they should use it too, starting off by rubbishing their current tool is a bad idea. Operating system zealots (of all kinds) should take note.
Looking at this question as a long-time Smalltalker, earning all my income doing web applications in Smalltalk for 12 years, what can I say about it?
First, is this a relevant question at all? Why Smalltalk needs to be popular? Isn't such small but nice and lively community as we have now a better thing than the big community?
On the other side being more popular is a good selling point. It is hard to persuade customers to go to less popular road, because they feel less safe.
But again, from my experience this is a non issue for the web applications. There almost no one care much what are you running-on, what they care is the result. That's why I think the future of Smalltalk is exactly in the web applications, because here we can explore all its strengths without dealing with that question again and again.
I think the reasons may have little to do with technical arguments. For example, the question is framed in terms of "why Smalltalk was dropped in favor of Java". I would ask why Java continues to be mainstream when its project failure rate is one of the highest in the industry (per Gartner, http://www.zdnet.com.au/news/business/soa/Java-and-Net-both-a-disaster-research/0,139023166,120269968,00.htm). Given that kind of evidence, this does not seem to be a rational phenomenon to me, and so I doubt that we (meaning programmers) will find proper, rational explanations to it.
Before we explain "why Smalltalk isn't popular", I think it would be much more interesting to answer "why do the majority of IT shops choose a technology that is associated with failure 70% of the time".
There are a number of reasons that Smalltalk didn't "catch fire", most of them historical:
when Smalltalk was introduced, it was too far ahead of its time in terms of what kind of hardware it really needed
In 1995, when Java was released to great fanfare, one of the primary Smalltalk vendors (ParcPlace) was busy merging with another (Digitalk), and that merger ended up being more of a knife fight
By 2000, when Cincom acquired VisualWorks (ObjectStudio was already a Cincom product), Smalltalk had faded from the "hip language" scene
Since then, Smalltalk has been a small player on the language space, but it's back to having a growing market. There are both commercial offerings (Cincom being the largest player there), and open source (Squeak, which is moving to MIT, and GNU ST, which is GPL).
Not all Smalltalk implementations require an image; while those of us who are sold on an image environment love it, you can use GNU ST with your favorite text editor easily enough.
Ultimately, Smalltalk peaked early, and then had damage done to it by the stupidity of the early vendors in the space. At this point in time, that's all in the past, and I'd say that the future looks pretty bright.
Some links to ruminate over:
The classic Worse is Better. Although pertaining to lisp, some of the same points apply. A simple solution that isn't quite right is better than a complex solution that is more difficult to transport across various boundaries.
Python.org This is not to start a language war, but more specifically, to show how easy it is to download, install, and start working on the language. For Linux, it's already there. For Windows/Mac, it's a quick installation away. Each comes with a huge amount of libraries that brings things like XML processing, http capabilities, and documentation for it all. Note the installation page for Squeak, not nearly as user friendly.
Libraries are also very important. Compare XML processing libraries for something like Smalltalk and then compare that to the almighty CPAN. Meanwhile each different version of Smalltalk has it's own library.
A programming language can be seen as many things. Some see it as a way of representing algorithms and data structures. In this case, languages like Smalltalk and Lisp and Haskell excel. It can also be seen as a tool that gets a job done. Even as they may curse the tool they use, they still would use what is needed to get the job done.
I was using Smalltalk commercially in a small way in 1995. ( I wrote my company's white paper on Java at the same time. IIRC I said Java needed 2-3 years more to mature)
By 1998, Smalltalkers ditched to Java.
Vendor licenses were very expensive. Squeak is magic at the price (nix).
The hardware required was outrageous: we had an early SUN UltraSparc with 1GB of RAM in 1996. It was a smalltalk application server. For one 3-tier application! With <50 users!! (Mind you, every field on every screen populated from the database in its own thread. Made for a very slick UI.)
Libraries are NOT the same between vendors so you get locked in.
Basic features of the environment are different between vendors: reflection is a curly one.
Basically the Smalltalk vendors have balkanized the market since the 1980's and it's still fragmented.
From a technical viewpoint Samlltalk stomps all over most other languages for productivity. NeXT copied the image-based approach of Smalltalk for Objective-C and it's done very well (just look at all of Apple's current products).
Penn State was/is big on Smalltalk. Entire student system and etc was written in it. Here is my reasoning:
If you really want a job doing Smalltalk babysit psu.jobs. They will lock you in the basement, maybe you'll get something to eat and get some sun, but you are not allowed to quit. You'll have a job 4evah...(diabolical echo of ...)
The Great Programming Industry Reboot sort of answers this. Short version: The first microcomputers couldn't run Smalltalk, and the number of programmers was growing faster than the new ones could be educated by the old ones. The programming culture basically started over in the early 1980s on microcomputers, and then the microcomputer programmers had to spend the next 30 years going through the growing pains that the mainframe/minicomputer programmers had already gone through.
You had to be there in 1995. At this time, there were a few commercial Smalltalks but the biggest was VisualWorks from ParcPlace Systems. The marketers at ParcPlace were idiots - choosing to optimize for max dollers per seat rather than max seats. Any shop wishing to adopt Smalltalk had to pay a couple thousand dollars per developer for a license. Any developer wishing to learn Smalltalk either had to get hired to do Smalltalk or sink serious cash into buying his own license. So it was just plain hard to get a chance to learn it.
Also about this time, IBM was looking for a successor to COBOL for their business customers. They chose Smalltalk (smart) and developed VisualAge and made it so the same program could run without modification from Mainframes to AS400s to PCs. Smalltalk has a friendly minimal syntax and is easy to learn so it seemed a natural replacement for COBOL. The future looked really bright for Smalltalk. The companies that were using it were out-producing everyone else by a lot.
And then Sun showed up with Java. The gave it away free instead of charging for it. IBM took a look at it and figured two things. First they didn't want to enter a marketing war with Sun that was clearly planning to spend a fortune on the Java brand. Instead they decided to try to beat Sun at their own game - have the best Java on the market. Why not, they already had a great VM that ran on their whole stack - they just adapted it to handle the Java bytecode set. In fact, all of IBM's Java tools were actually written in Smalltalk for several years. Thus - if one wants to blame anyone for the rise of Java over Smalltalk - it is pretty easy to place the blame directly at the feet of IBM and their unwillingness to compete.
I love Smalltalk. I love coding in the debugger, being able to archive processes and restore them exactly later if they encounter exceptions, the amazing reliability. The economy of expression and the brilliant class library. There is a new resurgence in Smalltalk development thanks to Squeak. Newspeak, Pharo (which has some really beautiful UI skins), the new cog VM, Seaside and Gemstone, these are all projects working on addressing the historical shortcomings of Smalltalk including the poor OS integration (Newspeak has a slick native widgets integration and Pharo/Squeak have a new external code integration capability called Aliens), and deployment/scalability.
Anyhow, I don't mind that Smalltalk isn't popular. That makes it a secret weapon for me and I am really encouraged to see all the new development projects. Smalltalk is growing and advancing again and this is good because a lot of the best ideas in software (XP, unit testing, refactoring editors, coding assistants) all were developed in Smalltalk first and then filtered out to the rest of the world (generally in diluted forms).
Last time I checked I was put off by the documentation. Why on earth should I put colored markers on my mouse just to understand what they are talking about? Is it so hard to call the buttons left, right, middle? See the beginning of Squeak by Example
Instead they are colors and I constantly have to look up what button is meant. This isn't a good idea to get into a flow.
I tested Squeak. And I don't know how somebody could deploy a Squeak application to "normal" people.
Two things stand out in my mind:
They seem like really obvious mistakes in hindsight, but I guess you just had to be there.
Very nice accepted answer. I would add that early Smalltalk systems weren't really on speaking terms with the host OS and its native applications. It was like APL: if you can live in this strange world called the "workspace" or "image", everything's great, but if you want to use your usual window manager or god forbid gnu emacs, well, you might as well be on Mars.
I believe Squeak still takes this approach, which is why I prefer Ruby :-)
A couple of people have mentioned syntax as a hindrance to adoption. I think there's a particular issue that drives a large number of developers away: lack of algebraic precedence rules.
Any language where the expression 2 + 3 * 4 has the value 20 isn't going to be a commercial success. Yes, the syntax is very regular, and yes, anybody who knows Smalltalk can figure out why expressions are evaluated the way they are. Unfortunately, it runs counter to what you've had drilled into you during your entire primary education in mathematics.
Anyone who's learning Smalltalk and is trying to use it to do basically any kind of calculation at all will run into this problem repeatedly until they learn that they have to parenthesize everything. Because it's only a problem with some expressions, and causes incorrect results, rather than an error message, it'll take them a long time to figure out the first N times it happens.
Some significant percentage of developers will never get over this.
Very silly licensing. There was a wonderful version of smalltalk in the 90s that delivered everything that a developer needed - great tools, excellent cross-platform development, good performance, reliability. This was VisualWorks. It was also not particularly expensive. I was prepared to look at it for major projects, after past success with Digitalk Smalltalk. But then, the company producing VisualWorks went bust, and VisualWorks was taken over by a company (who I shall not embarrass by naming) who changed what would have been a simple purchase of a development product into an absurd licensing arrangement which required an on-going and expensive "customer relationship". In doing so, they killed the chances of this wonderful product becoming mainstream. At the same time, Sun were supplying Java for free. Cross platform, multiple supplier (Sun and IBM vms), secure, with a syntax familiar to C developers. They also put a huge effort into optimising the JVM, which means that these days Java can easily compete with C in terms of speed.
These days I develop in Java, groovy and Scala on the JVM. But I miss Smalltalk development.
Isn't it? According to TIOBE's list, it's #44 right now. #44 in the world seems pretty darned popular, to me! (Porsche is also about #40 in the world, in terms of popularity, but nobody seems to ask "why isn't Porsche popular?".) We've made huge strides in using open, text-based protocols; who cares if somebody else uses the same programming language?
Especially for a computer language that's 40 years old -- how many other languages from the 1950's and 1960's do you see in use today? I see, of the top 50, only 6 others: Logo, Pascal, RPG, COBOL, Lisp, and Fortran. There are a bunch of languages with high instantaneous popularity, but which are very likely to drop off the list in well under 40 years.
I would consider a top-50 language that's been there for 2 (human!) generations to be much more solid than a top-10 language that's been there for only 3 or 4 years. The latter is likely a fad; the former is a proven classic.
Shakespeare and Twain and Poe are not top-50 authors this year, but may well be top-50 authors over the past 40 years, and I think it's pretty likely they're top-10 authors over the past century. They all use an open, text-based protocol (English!), so it doesn't matter that the person next to me on the bus is reading a short-lived fad like Danielle Steele.
I as a Smalltalk programmer in the 90s, and then again more recently. I'm surprised that I can relate to almost every person who wrote on this thread (with a couple exceptions).
Yes, in the mid-90s, the vendors priced themselves out of the budding market, failed to get bundled into Netscape, and basically got themselves booed off the stage.
The particular ingenuity that came from the Smalltalk environment was a product of its inherent strength, which is still there. Smalltalk has the potential for reinventing itself, or more precisely rediscovering its purpose for a new age.
Since Smalltalk isn't very famous, it's hard to land contracts, and the true Smalltalkers often find themselves shuttling from one city to another for engagements. On the other hand, the smalltalk community, for a better or worse, means people actually know each other. In these days, being a part of a community, even a back-biting nerdy one, has its advantages. Professionally speaking, people know who you are. Since Smalltalk tends to attract mavericks and dreamers, like me, it's a good place to be.
"the more I learn the more I’m impressed"
You can learn some more about real Smalltalk applications from conference experience reports - read through Niall Ross's conference summaries.
The huge fricken images.
They're a horrible way to distribute software. Get with the program, make a distributable version of smalltalk that makes executable or at least self bundles and has access to normal GUI toolkits or at least look alike ones.
The only people who can really use the language are those running on servers, a la, those who do not have to distribute it.
The primary reason seems to be liter upon liter of misinformation, fermenting to misperception by the galoons. Secondary reason is probably the ParcPlace mis-step of the mid 90's, third is likely losing the one mega-player, as IBM veered off to engage a MS guided war of attrition, getting sucked into the black hole of a collapsing Sun.
Popular - like Paris Hilton?
Or quiet pursuit of craft, immersed in the joy of working with great tools, which likewise persist, improve, and grow, albeit in relative obscurity.
To each his own, I guess.
Having used many, many, many tools over the years, I can say that Smalltalk simply IS worth the price of admission, whatever that price appears to be.
Dig in. Due diligence, and all that. You'll only make things better for all of us. You could even screw it up, make it wildly 'popular', and we'd still come out ahead. Up to you.
Speaking as someone who has used VisualWorks in school, there are a few things I found annoying. The biggest was the forced (yes, forced) use of the image environment. 2/3 through my project, the image environment crashed while I had a particular window open. That caused the window to come up every time, I opened the environment, despite many efforts to correct this issue. I also found (what I saw as) the weak namespacing and scoping irritating. "Everything is an object" sounds cool until you realize what it means, that 3 + 4 * 7 = 49. And though I understand where duck-typing is coming from, I still strongly prefer static type-checking. The syntax was not that intuitive; I know Java is verbose, but it's actually easy to read and write, especially (obviously) for someone who came form a C/C++ background. This is true even though Java is (almost equally) distinct from C/C++ where it counts (e.g. memory management and object-oriented model).
But I do respect certain aspects, not least the many features it originated, such as strong reflection and powerful closures.
This is a much-pondered question. In fall there will be a talk about it by Giles Bowkett at ESUG: http://gilesbowkett.blogspot.com/2009/05/upcoming-presentations-in-fall.html.
In this interview Robert Martin gives his point of view about this discussion: http://pragprog.com/podcasts/show/32.