News for hackers. Stuff that matters.
Re:The Early History Of Smalltalk (1993) by hboon on Wednesday September 05, 2018 @12:12AM (#17914977)
The short answer is it's different and unfamiliar to most newcomers:

1. The image-based paradigm [1] holds it back. Using Smalltalk, there's quite a change in development style, the existing development tools (text editors, version etc) mostly don't work [2], and deployment is at least slightly different.

2. The unfamiliar UI (mostly Morphic) looked very different.

3. The different (but incredibly simple) syntax looks strange to newcomers.

There are paid tools that fix some of these, but they never quite caught on with lots of momentum, and they were used mostly in bigger enterprise shops. The biggest might have been IBM VisualAge (for Smalltalk), which later morphed into IBM VisualAge for Java and then Eclipse.

[1] The image-based paradigm is really really great. If you haven't experienced it before, give it a go. It's worth it even if you are never going to use Smalltalk. [2] There's been effort to get git to work. I haven't been tracking it, but this was only in the recent few years.

Re:The Early History Of Smalltalk (1993) by leoc on Wednesday September 05, 2018 @06:10AM (#17916547)
Apparently (not an expert) [1] Smalltalk was the leader in basically the Java niche until Java happened, whereupon the proprietary and rather expensive Smalltalks were wiped out, since not only was Java free as in beer and reassuring to C++ programmers, it also came in riding a truly preposterous hypewave. (For those who weren't there and haven't heard: it was roughly cover-of-Time-magazine scale. It was visible from space.) Then HotSpot—retrofitted from the Self VM, ironically—gave Java a performance advantage which (iirc) the existing ST VMs couldn't match. And while Smalltalk was almost the paradigm dynamic language, the proprietary STs had no impact in the scripting-language niche thanks to their licensing costs and inward-looking, image-based nature. (GNU Smalltalk was another story: I don't know what happened or failed to happen there.)

[1] There was in fact an article written by someone who was an expert which did the rounds of /r/programming back in the day. But good luck finding it now of course.

Re:The Early History Of Smalltalk (1993) by pjmlp on Wednesday September 05, 2018 @07:24AM (#17916904)
You missed the part that IBM was a big Smalltalk vendor and they rebooted their product offering into Java, including Eclipse which has its roots on Visual Age for Smalltalk.

Eclipse to this day still has a Smalltalk like code browser for Java code.

Also in the early days although the JDK was free beer, all good IDEs were commercial, Eclipse and Netbeans only came a few years later.

Re:The Early History Of Smalltalk (1993) by z3phyr on Wednesday September 05, 2018 @09:28AM (#17917707)
There was also Inferno[1] and Limbo[2] from bell labs touted as the future, some very good ideas..

[1]https://en.wikipedia.org/wiki/Inferno_(operating_system) [2]https://en.wikipedia.org/wiki/Limbo_(programming_language)

Re:The Early History Of Smalltalk (1993) by 3rdAccount on Wednesday September 05, 2018 @06:35AM (#17916644)
I think it is called "Why Smalltalk failed" and is easy to find with a search.

Java was web, Perl was web, and ST wasn't ready. Java and Perl were free as in beer, ST was expensive. I think ST hardware was expensive too. ST is very different from C & C++. ST had multiple vendors too.

Re:The Early History Of Smalltalk (1993) by leoc on Wednesday September 05, 2018 @07:33AM (#17916958)
"why smalltalk failed" may afaicr have been first thing I tried: https://www.google.com/search?q="Why+Smalltalk+failed" . https://medium.com/smalltalk-talk/why-smalltalk-failed-to-do... isn't the article I was looking for. It's much more recent, and much less in-depth. However http://wiki.c2.com/?WhyIsSmalltalkDead covers a lot of the same ground, unsurprisingly.

I'm pretty sure that late-'80s/early-'90s ST was largely run on commodity (or fairly-commodity) hardware: PCs, Macs, Unix workstations. It was commercial Lisp that tended to be tied to dedicated hardware. IIUC Smalltalk did have a then-expensive appetite for RAM though.

The commercial STs of the time weren't good as CGI languages like Perl and PHP for the same reasons they weren't suitable as Perl-style scripting languages in general. Meanwhile, behind the hype it soon turned out that Java applets were not ready for prime time either, while servlets were something that could probably have easily been replicated in ST (and for all I know, likely were).

Re:The Early History Of Smalltalk (1993) by kristianp on Wednesday September 12, 2018 @08:54PM (#17974999)
googling

   site:www.reddit.com smalltalk leoc
one of the results is:

Bambi Meets Godzilla - "I watched Smalltalk die."

https://web.archive.org/web/20080706101400/http://www.oreill...

Re:The Early History Of Smalltalk (1993) by flukus on Wednesday September 05, 2018 @01:07AM (#17915158)
> The image-based paradigm [1] holds it back. Using Smalltalk, there's quite a change in development style, the existing development tools (text editors, version etc) mostly don't work [2], and deployment is at least slightly different.

It holds it back because it's a bad idea, otherwise Access/VBA apps would rule the world by now. It's a great environment for single developer RAD tools but it's horrible when you're trying to scale the team up because tools like git don't work well and you often don't want data to be shared between instances.

Re:The Early History Of Smalltalk (1993) by hboon on Wednesday September 05, 2018 @01:21AM (#17915203)
git didn't work with it (maybe it does now). But there has been native version control tools in Smalltalk. There was ENVY, and Squeak and Pharo has Monticello, Dolphin had something (can't remember its name).

git is great in many ways, especially how it lets multiple developers to work more effectively on the same code base. But native version control tools on Smalltalk, while they might not work as effectively for large groups of developers, has native support — it can support things like versioning at method level.

Rather than arguing Smalltalk is the best or that it is bad, I rather focus on what I think — it has many great features, it's just that it's so different that it can't ever be popular, at least not for the foreseeable future.

Re:The Early History Of Smalltalk (1993) by goatlover on Wednesday September 05, 2018 @12:42PM (#17919597)
Well git was made for text/file based programming languages. If SmallTalk had taken over instead, we would have the equivalent for image based languages.
Re:The Early History Of Smalltalk (1993) by int_19h on Wednesday September 05, 2018 @12:29AM (#17915036)
How exactly does the image-based approach mesh with version control like git? I'm trying to picture a possible approach, but failing.
Re:The Early History Of Smalltalk (1993) by hboon on Wednesday September 05, 2018 @12:41AM (#17915074)
Smalltalk has a concept of changesets. They can approximate diffs/patches.

And while the code is exposed in code browsers (some kind of IDE/text editor window) in the image, and not exposed as text files, they certainly can be. So I'd imagine it's just a matter of exposing those into files (or still classes and methods as separate "entities") and commit those into git with a bit of markup.

Re:The Early History Of Smalltalk (1993) by int_19h on Wednesday September 05, 2018 @12:44AM (#17915080)
But the whole point of the image approach is that it's not just code, but also data, no? It would seem that it'd require some multiple-file text-based serialization format for images that would include both code and data, and would split it into files in a way reflecting the typical change patterns...
Re:The Early History Of Smalltalk (1993) by hboon on Wednesday September 05, 2018 @01:05AM (#17915151)
Code + data + live instances of the code/objects. Like I said, I haven't been tracking how they do it, but I'm guessing that they only track code. If you want to be able to deploy an image directly, you either have to write scripts (and check those in too, either standalone "scripts" or class-side initialisation) or save the entire image and deploy that.

Saving the development image and deploying it directly is also not done that often because the development image contains things that can stripped off, e.g. development tools or object instances you use during development. Squeak and Pharo is usually distributed in various flavours, loosely — full and minimal images (I might not get the names right). So you take the former and install packages for development and the latter + packages for deployment, or you can build your own from the minimal image.

But through this you can see how different it is and while it's great in many ways, some of the differences make it harder for newcomers to start and harder for everyone to use it in production.

I forgot to mention Dolphin Smalltalk http://www.object-arts.com. It used to be a paid product, running on Windows. It has been open source for a few years now. I think product sales wasn't sustainable for the owners. But for several years, it is was the best Windows thick client development tool. It's a great example of Smalltalk well-done. You have the same image-based approach, but the windows are all native and familiar looking, so basically a multi-window development IDE. There's a deployment tool that helps you to strip down your image and build it into an exe (which was basically the Dolphin Smalltalk image + the shrunk image). It might still run, maybe it looks a bit outdated, it was actively developed until 2004 or so. If it still works, it's a wonderful way to experience Smalltalk.

Re:The Early History Of Smalltalk (1993) by protomyth on Wednesday September 05, 2018 @07:33AM (#17916960)
At a place I worked they checked the changed / added code[1] into a conventional version control with all our other code. There are quite a few adapters available. The final image deployed to production was a starting generic image which the build team applied all the code from the version control. Worked just fine. If image-based approach is the deciding factor, it really shouldn't be. There are tools.

1) Smalltalks have a text output format for code chunks

Re:The Early History Of Smalltalk (1993) by anothergoogler on Wednesday September 05, 2018 @12:43AM (#17915076)
I believe Monticello has been the mainstream Smalltalk VCS for some time, but I don't know much about it: http://wiki.squeak.org/squeak/1287
Re:The Early History Of Smalltalk (1993) by rjsw on Wednesday September 05, 2018 @04:28AM (#17916070)
GNU Smalltalk isn't image based.
Re:The Early History Of Smalltalk (1993) by scroot on Wednesday September 05, 2018 @12:35AM (#17915053)
Re:The Early History Of Smalltalk (1993) by coldtea on Wednesday September 05, 2018 @01:50AM (#17915327)
An image could be serialized to anything, including edits...

Aside from the code, all other user data is message sending, so it could also be serialized (if needed).