The Slate Programming Language

An anonymous reader writes "I know that we have had an influx of new programming languages of late, but I feel that this one merits special attention. Theoretical computer scientists and long-time Squeak and LISP contributors Brian Rice and Lee Salzman have been rapidly developing a language called Slate. It draws on the various strengths of the Self, Smalltalk, and LISP languages. To quote from the website: 'Slate is a prototype-based object-oriented programming language based on Self, CLOS, and Smalltalk. Slate syntax is intended to be as familiar as possible to a Smalltalker, rather than engaging in divergent experiments in that respect.' The beta release is currently being written in Common LISP."

Deja vu

[spellraiser]

Slate is a prototype-based object-oriented programming language based on Self, CLOS, and Smalltalk.

From a recent [slashdot.org] post:

Prothon is a new industrial-strength, interpreted, prototype-based, object-oriented language that gets rid of classes altogether in the way that the Self language does.

Does this point to a trend in language design?

Re:Too obscure

[Anonymous Coward]

In Smalltalk, closures are fundamental. Without them you can't do if statements or whiles or anything else.. Smalltalk closures are very simple.. in Lisp their are a bit more intimidating to the unitiated.

Re:Too obscure

[Animats]

Well, it's one solution to the "how do I return a temporary" problem. There's elegance there. But it's expressed in an unnecessarily obscure way. The reference-counted Perl model is equally powerful but more comprehensible.

April fools..I hope

[rufusdufus]

Confusing things like:

3 + 4 * 5 " ==> 35 (not 23) "

and

(3 / 4) == ( 3 / 4) "==> false"

give pause for concern.

But the example code snippet for the curious @ dispatch operator uncommented and unexplained takes the cake:

"
oc@(OrderedCollection traits) copyFrom: start to: end
[| newOC |
end start ifTrue: [^ oc newEmpty].
newOC: (oc traits newSize: end + 1 - start).
start to: end do: [| :index | newOC addLast: (oc at: index)].
newOC
].
"

How could someone argue with a straight face that this gobblygook is progress in programming languages?

Re:Ah, great, Smalltalk

[Anonymous Coward]

Great, indeed. I'm always amazed by comments like this. How on Earth a language designed to be easily used by small children ever acquired this lofty "ivory tower" connotation I doubt I will ever know. I've been a professional Smalltalk programmer for the last ten years. The language is literally child's play, working with it is easy and enjoyable, building large complex systems with it is trivial, maintaining them is also rather painless, the tools that are typically bundled with it are incredibly powerful, the tools I've built to go along with it have been easy to build, the community itself is very friendly. I've never come across this attitude that you describe. There are some very sharp people in this community, I would assume that there are some very sharp folks in other language communities as well. As for myself, I've never considered myself to be a master programmer, but as one person put it, "the power of Smalltalk is to allow mediocre programmers to create powerful systems". Not exactly flattering, but there is a lot of truth in that. It certainly makes my life a great deal more enjoyable. The simple truth is that most programmers, whatever language you consider, are not gurus. Never underestimate the power of a computing environment that began with the notion of giving end-users power equal to that of those who created the environment. It lets ordinary programmers such as myself look good on a daily basis.

ain't nothin' wrong with prototype OO

[Laxitive]

Man, and here I am writing my own little VM for a prototype OO system.. seems to be all the rage nowadays :D. I'm liking the recent trends of languages evolving to use simpler and simpler higher level semantics. I am a fan of smalltalk and self, but not their syntax. Their language environment and semantics, though, are worth pursuing.

One of the reasons I like prototype OO (specifically, delegation-based prototype OO, as opposed to languages that use embedding), is that a lot of _other_ dynamic language models fit well on top of it. For example, it would be very simple to make a Python -> Self compiler, because constructs that self exposes can be used directly to implement more specific class-oriented pythonic constructs. It leads me to beleive that a prototype-oo oriented base-vm can serve as a good abstract platform environment for several dynamic 'scripting' languages.

I'm not sure about the multiple dispatch though. I think multi-dispatch can be confusing.. especially in languages like these where the notion of runtime types is muddled quite a bit of the time.

-Laxitive

A better smalltalk-like language

[cryptoluddite]

There are other Smalltalk-based languages that are far better than this, for example SmallScript [smallscript.org]. The guy behind it, David Simmons, is trying to learn from Smalltalk's mistakes:

• Isolated, all-in-one environment creates a with-us or against-us situation. Smallscript can plug into .NET, and you can embed C++ or other language code directly into the program and link to external code.
• Slow performance. Smallscript is targeted more at scripting, where performance is less critical. Even the best Smalltalks average about 1/10th the speed of C on common codes. All Smalltalks are significantly slower than Java.
• Complete lack of security. Smalltalks allow dynamically loading and running code (there are even smalltalk-lets like applets), but have no provisions for Java-like sandbox security. Smallscript has some provisions for security and can leverage .NET's security.
• Unnatural language syntax for programming. Smalltalkers claim their language is more like English, but most programmers just don't like it. Smallscript has added a few C-like keywords and syntax.
• Lack of solid, stable core. One of Java's strengths is a huge core library that is unmodifiable by applications. This means that everybody knows what the core does and what is available in it. Smalltalk core is flexibly, where developers add methods to objects on a whim and re-writing the actual code for the core objects. This means that apps are not portable to future language runtime versions and can't co-exist with other applications.

This new Slate language looks just like Smalltalk only with new features that nobody actually wants, such as prototypes instead of classes. AFAICT, it hasn't improved on any of the above problems and has actually made some of them worse. IOW, it's doomed.

Scallscript is a start. It's definitely the best of the breed. Personally, I think the greatest barrier to acceptance of Slate / Smalltalk / Smallscript / Squeak / Whatever is the language syntax. Programmers just don't yoda talking like, and a slightly-off Germanic style of grammar just doesn't fit well with an activity like programming that is more mathematical and logical than like communication.

Re:Pretty Cool

[be-fan]

Dylan is very not prototyped-based. Its class-based. Extremely cool language, though.

Re:Ah, great, Smalltalk

[platypussrex]

In grad school our compiler class had to write a basic C compiler (standard fare I know). Was a good learning experience and all that (actually I wrote mine in Macintosh Pascal just to freak the professor!) Then in a course in OOP the class did a group project to create Smalltalk (only got about half of what we wanted done... that's the nature of groups I think) Was my first exposure to Smalltalk and to OOP and really liked Smalltalk. Have always thought that students getting their first exposure to OOP would be much better served using Smalltalk than C++

Later a graphics class was done almost entirely using Smalltalk (by a visiting professor) and people from previous years were amazed at everything we got done. Never had a chance to program in it professionally, but many good memories of it. Have never had a slightest sense of elitism etc from those using it either.

Re:Prototyping OO is not a great paradigm

[LittleDan]

What's wroing with prototype OO? You can use it in a completely class-based way if you wish. Prototyping only allows more flexibility. Many things in OO languages, such as Python exceptions, require a hierarchy of objects so they use classes. But this a hack; exceptions are objects, not classes. Although prototype-oriented languages haven't been used extensively in buisness contexts, neither have languages with type systems more advanced than Algol because the jump to a language that's not directly decendent from C is too great (unless it's from Microsoft, but for Microsoft they'd switch to assembly if it was marketed properly). Compared to FP, prototypes are almost completely unused in academia or any other sort of "ivory tower". What makes it difficult for inhreritance management? Daniel Ehrenberg

Re:prototype based languages

[Piquan]

Being a Lisp programmer, I'm always looking for new ideas to bring into my Lisp programs. It looks like Lisp-- possibly even CLOS-- could support prototype-based programming without extensive pain.

One thing that I'm wondering about in prototype-based OOP is redefining stuff. In Smalltalk and CLOS (I don't know Self), you can redefine methods over classes on the fly, or change member variable definitions, or whatever. I take advantage of this to have a production server running for months while I make improvements.

But in a prototype language, this looks, well, difficult. If your methods are associated with prototype objects, then if you have existing non-prototype objects and change a method, then would the non-prototype objects get the method def passed down, or what?

It seems like a prototype language would also have problems with multiple inheritance and multiple dispatch, but it looks like they've licked those too. Interesting.

Re:Dylan was hardly successful

[DrEasy]

True, but Smalltalk was about to hit the mainstream right when Java took off. I used to get spontaneous job offers around 98 just because of my Smalltalk skills. European banks in particular were replacing their old cobol code with Smalltalk, so there was money to be made there.

But Smalltalk couldn't rival Java in terms of marketing, and applets were supposedly the next big thing. If only ParkPlace had come up with a Smalltalk equivalent to applets...

Re:Pretty Cool

[ron_ivi]

If I recall correctly, one of the guys behind Dylan ended up working on another MIT-based Lisp-Like language called Curl (more info at Curl Corporation [curl.com]).

It did a great job at bringing all the power of Lisp with all the symplicity of HTML. All the equivalents of HTML elements were just lisp-like function calls. Something like

(text this is (font color=red size=+2 big red text))

Since all markup was just a lisp-like function call like any other, extending the company to do more complicated things - like extending the HMTL-like-markup to do real time raytracing in the browser [curl.com] was really easy.

Unfortunatelly the company suffers from bizzare licensing policies and can't figure out if they're selling a language or products built on the language.

Re:Dylan was hardly successful

[be-fan]

So what? At this point, I've given up ever hoping that the "programmers out ther ein the trenches" will ever wise up to the superior tools that are out there. There is no point in bringing those people into discussions about languages, because they'll never accept something unless its almost exactly the same as what they are already using. Witness C#, which is ever so slowly absorbing Lisp techniques. So far, it has GC, and in 2.0 will have lambda. In another decade, it'll get multimethods, another decade later it'll get macros. By about 2030, they will have matched Lisp circa 1980.