Hacker News Reader

Self gets used by the enthusiasts in production, for a suitable definition of production. I believe the Self website is served by a webserver written in Self for example. I've also served my blog in the past from a Self webserver.

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.

Yep, the Self website is running on a Self webserver (which is itself running on a half written Self cloud). Seems to be fairly stable, all things considered.

I wonder if Smalltalk doesn't have much larger community now, than it did in the 80s. Sure, other languages are bigger still -- but if we have, say a thousand times as many Smalltalk programmers today, as in 1980 -- then hopefully the language will keep getting better. Especially since there are now a few Free/open source implementations, tutorial/books and frameworks.

SmallTalk was taught as a course when I was at University in the 90s. I doubt that's the case now even though conceptually it's a good language in a CS education. We also had courses with functional languages (at that time ML) and Lisp was taught with AI.

Maybe. I don't think being featured in CS education is all that interesting (for fringe languages). I was thinking more along the lines that computing is becoming way more accessible all the time (for one thing a full Smalltalk image+vm is no longer a "large" download) -- so the number of people contributing to Seaside, Pharo etc might be growing.

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...

Unfortunately, modern smalltalk environments (pharo, squeak) are terrible compared to modern Common Lisp implementations.

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.

Same - I did Programming 1 and Programming 2 in VisualAge for Smalltalk in 1997

Hmm, I wonder if Pharo/Squeak publish their download numbers? Is the recent uptick in smalltalk articles on HN an indicator in increasing interest in the language (even though they've been mostly harsh).

> Languages invented by enthusiastic geeks can succeed, but they don't take over the world.

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.

Actually, those are the very languages I had in mind. Perl too. Yes, they have many more active developers than Smalltalk. But you know what? I was part of the Ruby community before Rails, and it was tiny. That was after it had been around for 10 years.

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.

>Actually, those are the very languages I had in mind. Perl too. Yes, they have many more active developers than Smalltalk. But you know what? I was part of the Ruby community before Rails, and it was tiny. That was after it had been around for 10 years.

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.

> 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.

Having support from third party vendors is not the same as succeeding because you have the backing of a major vendor (and especially one who created you), like Java or C# or Swift.

C would have been a footnote in the history of programming languages if AT&T didn't offered the code to a few universities, whose students created the UNIX workstations like in Sun's case.

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.

C was invented at Bell Labs, a subsidiary of AT&T. Surely that counts as "backing of a major vendor"? C spread along with UNIX, which AT&T as vendor licensed to many other companies. It was also helped along by AT&T's own use of C and UNIX in its internal systems, especially telephone switch development.

Ruby, Python, and Lua were all created in the early nineties, when the alternatives were Tcl and Perl. And it still required each of them a decade or more to take off.

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.

> The only language that is successful purely because of the backing of a large company is Swift.

Rust and Go seem to fall pretty firmly in to that category as well.

I wouldn't really call Rust isn't successful yet, though it showing signs that it may become that way. Go, maybe, its at least farther along the path.

>The only language that has come out recently that is successful purely because of the backing of a large company is Swift.

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.

don't capitalize the T. Just Smalltalk. It's cleaner

>Sigh. Nothing killed Smalltalk. It's not dead. Neither is Scheme. Yeah, both of those languages have pretty small communities

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.

Oh stop picking his reply apart when you exactly what his point is: if you consider smalltalk "dead", and you are "going to invent a cool new language" then you can probably get into the BACK of the popularity line, after REBOL or whatever, as basically you aren't worthy... not even close to worthy...

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.

>then you can probably get into the BACK of the popularity line, after REBOL or whatever

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.

I don't think you got his comments to you at all.

I don't know, I think I just disagree with his points (and agree more with the article).

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?

Scheme is actually used quite a few places, just not as much as a general purpose implementation language.

I would say that smalltalk is way more "dead" in the sense that news doesn't make waves the same way scheme news does.

>Scheme is actually used quite a few places

Don't leave us hanging, I'm sure lots of people would like to know of Scheme success stories besides Jak and Daxter.

http://c2.com/cgi/wiki?LispInJakAndDaxter

lilypond is a big one. Better music notation quality than finale and sibelius.

OS X ships with a couple hundred files worth of Scheme related to sandboxing:

    mdfind -name .sb

former PLT scheme = Racket...

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...