I found the comment in the post about how a few lines of code would be better than the object interactions in the GUI interesting. I thought this would be the case when I started using Self too but even with the GUI you still write code. The method bodies for example are all textual code that feels like programming in any other language.
Where the GUI excels is exploring systems, prototyping designs - and then refactoring the design towards a production implementation. It also makes the applications 'live' for users. They can drill down into the application objects and see how things work. The line between OS, application, and development is very blurry in Self.
I also wonder a bit about Gemstone/GLASS (the ones behind the Ruby maglev vm/system).
As for packaging as others have commented on, I found[1] -- but I think things like the rise of quicklisp[2] shows that these truly powerful languages (and I think Smalltalk is indeed "lisp powerful") can spring up from the brink of death/irrelevance through the serendipitous release of a framework/tool/technique etc.
It just occurred to me that it might be interesting to implement Smalltalk on top of Racket as a language -- Racket has (seemingly) great support for creating deployable executables[3].
[1] http://forum.world.st/Create-a-exe-application-in-Pharo-2-0-...
[2] https://www.quicklisp.org/
[3] http://docs.racket-lang.org/raco/exe-dist.html
[4] See eg: http://queue.acm.org/detail.cfm?id=2068896 for an example "Adventure"-like language. Or scheme-without-parens: http://pkg-build.racket-lang.org/doc/sweet/index.html
PS: Related to Racket and languages, I also came across this nice little post:
"7 lines of code, 3 minutes: Implement a programming language from scratch" http://matt.might.net/articles/implementing-a-programming-la...
The libraries are not there, monticello doesn't even support HTTPS last I checked, nevermind cryptographic signatures, they don't support concurrency via native OS threads, the FFIs are a joke (just take a look at pharo), the graphical environments are laughable (pharo and squeak look like total crap on OSX retina machines, the font rendering gives you headaches, yes it's THAT bad), performance is abysmal, I could go on for ages...
Common Lisp on the other hand has multiple mature opensource native code compilers (SBCL and CCL) that support multiple platforms, concurrency via OS threads, have amazing foreign function interfaces, performance that is close to C, optional paid support for the opensource implementations, a development environment that is more traditional but also lets you program 100% interactively from within the image without compromising when it comes to interfacing with traditional version control, also support snapshots and so on.
Smalltalk is more "dynamic" than Common Lisp and is also better (in theory) when it comes to interactive development. But in practice, Pharo and Squeak are stuck in the 90s at best and compromise in areas that today are of paramount importance. Common Lisp doesn't and gives you all the options.
Ruby, Python, and Lua are all obvious counter-examples to the idea that enthusiastic geeks cannot create languages that are many orders of magnitude more successful than SmalllTalk and Scheme. Even CoffeeScript, if you can call it a complete language, is in the realm of that success.
The only language that has come out recently that is successful purely because of the backing of a large company is Swift.
This was also at a time when most programming languages did not have free implementations and companies actually sold compilers and interpreters. The programming language landscape was totally different back then.
So I'll say it again. If you want to create a new language, go for it! But I wouldn't sneer at Smalltalk and Scheme in the process. Those communities are relatively small, but they're still huge compared to your brand-new language, and they will be for decades. And if you judge language success by innovation and influence rather than developers... well, you have even bigger shoes to fill.
So? Languages might take a while to catch on. Ruby has a huge community and lots of jobs now. And Python has had that even without something like Rails to dominate adoption. Perl was also huge back in the day.
As a counterexample Dart is nowhere near even Ruby pre-Rails was, even though it's from a major vendor.
And of course C, C++ etc didn't succeed because they had the backing of a major vendor, like Java or C# did.
C - AT&T, UNIX vendors
C++ - Almost all C compiler vendors adopted it. CORBA and Windows Development helped it.
In the late 80's the language had zero value in the hobbyist world.
The few compilers that existed generated crappy code, were not even K&R compatible and only mattered to those that had access to UNIX either at work or university.
Rust and Go seem to fall pretty firmly in to that category as well.
We don't know that. I mean it's not like ObjC, where the main pusher and motivation to adopt it was Apple having it for OS X (as evident by the relative lack of adoption of ObjC in Linux, NextStep etc).
Swift does have got people genuinely interested to use it even outside the Apple ecosystem, they just don't have the chance to, yet.
That's how we define "dead" for languages: "pretty small communities".
>but that's viable in the Internet Age.
Viable to exist and continue having small communities. But not viable for what matters to lots of people, mainly being able to use them for their company/projects with great support from various sources, documentation, books, new releases and bug fixes commining round the clock, and answers for their questions on Stack Overflow.
in a nutshell, a still-revered, still-used (niche public) language built by people with an actual high-level concept (TDD) from the academic world with the support of much of industry at the time, said language probably can safely stay on it's pedestal despite such a fluff-brained "analysis" as linked article purports to provide...
i mean the central point of this article is: "I'm going to make a language that will be big and smalltalk is a convenient hoity toity strawman for me to knockdown"
weak.
I don't know. Golang, Rust, Clojure and Scala seem to do quite well for themselves, quite better than Smalltalk.
I don't have exact numbers of course, but considering job postings, use by high profile companies, books coming out, conferences, tooling created, blog posts and HN articles, they are way ahead of Smalltalk today.
Besides this:
>as basically you aren't worthy... not even close to worthy...
Sounds fishy to me. Even if you're not worthy there's no reason not to try if one wants to. And that's how we do get the 1 in 10.000 languages that ARE worthy anyway.
He says: " a still-revered, still-used (niche public) language built by people with an actual high-level concept (TDD) from the academic world with the support of much of industry at the time, said language probably can safely stay on it's pedestal despite such a fluff-brained "analysis" as linked article purports to provide..."
To which I disagree. What do you think I didn't get?
I would say that smalltalk is way more "dead" in the sense that news doesn't make waves the same way scheme news does.
Don't leave us hanging, I'm sure lots of people would like to know of Scheme success stories besides Jak and Daxter.
it's a tight little platform! batteries included... check out DrRacket, and it's dependency graphs that appear upon mousing over defined words...it will even show graphics and mathematical symbols in the REPL if that happens to the be the domain of the functionality you are testing... loads of libraries available... great package system. there's a pretty basic thread-per-connection web server (extension of a generic server i forgot the name of) included and you can get up and running building something very very quickly...
mdfind -name .sb
Heck, even Self, which nobody ever used for actual shipping software (as far as I know), still has some life in it. The latest release was last year and runs on Linux, Mac OS X. (What, no Solaris support?) http://blog.selflanguage.org/2014/01/12/self-mallard-4-5-0-r...
Compared to Self, Smalltalk and Scheme are downright mainstream, and used in all sorts of production software.
This is important if you're planning on inventing a new programming language. The chances that you create the next Javascript or Java are slim to none. Those languages are platforms that are backed by large companies. Languages invented by enthusiastic geeks can succeed, but they don't take over the world. Even when success does come, it's after decades as niche languages with tiny communities.
If you consider Smalltalk and Scheme dead, be prepared to have your language be stillborn.