The Slate Programming Language 244
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."
Re:Ah, great, Smalltalk (Score:3, Insightful)
Obligatory. (Score:3, Insightful)
Use what is best for the situation and don't whine.
Too obscure (Score:3, Insightful)
A block closure is an object representing an encapsulable context of execution, containing local variables, input variables, the capability to execute expressions sequentially, and finally returns a value to its point of invocation. The default return value for a block is the last expression's value; an early return can override this.
This is a language for people who like obscure semantics.
Yes, closures are useful. I've used them in LISP. I even used one once in production code in Perl, to do some error handling cleanly. But when the manual starts out with closures, it's clear that somebody is getting too cute.
This is a language for "l33t haxxors", of the old MIT AI Lab persuasion. Check out "instance specific dispatch". Now that's designed to totally confuse maintainers.
Re:why slate (Score:4, Insightful)
Or maybe, just maybe for once we could acknowledge that programmers are smart people and can learn new things. Lets get off trying to bend over backwards and make a broken language better -and- backwards compatible. This is exactly why C++ is the horror that it is today. Write a new clean language and just make sure that it links well with others. Then you can call functions from your old programs written in whatever the hell language you want, nobody knows and the code slowly moves over to a codebase that doesn't rape the programmer (like trying to use exceptions in a C++ program without the exception killing you!).
Re:Too obscure (Score:1, Insightful)
Closures are fundamental to most functional programming languages and smalltalk. They're useful, all programmers should understand them.
They are not an obscure concept. Good programmers use them all the time.
Re:Obligatory. (Score:1, Insightful)
Well done - it's one of the etcs. There are applications out there written in Lisp, Haskell, Smalltalk, all sorts of weird and wonderful languages that the C world knows little about.
You've probably used some of them without even realising.
Re:Too obscure (Score:3, Insightful)
14.upto(19) do |i|
# do
end
so, the closure is executed 6 times, the first time with i = 14, the next time with i = 15, the third time with i = 16, up to i = 19.
Just have a closer look at Ruby, and you will see that the whole standard library is built on top of this simple and elegant concept. The book "Programming Ruby" can even be read online and downloaded from www.pragmaticprogrammer.com [pragmaticprogrammer.com].
Re:April fools..I hope (Score:3, Insightful)
As it has always been in the smalltalk family of languages (which includes basically Smalltalk and Self). This was once considered a necessity as smalltalk was interpreted strictly as a stream of instructions (much like forth is now), but now that it's always compiled, I rather wonder whether this isn't legacy baggage. Certainly flexible overloadable operators aren't inimical to the notions of operator precedence, as the ML language family shows.
I certainly don't get why (3/4) != (3/4). If it's because it's inexact, they might learn a thing or two from how scheme handles it.
> [snipped example]
> How could someone argue with a straight face that this gobblygook is progress in programming languages?
Syntax-wise it sure isn't, it looks like slavish adherence to smalltalk's syntax, with Self's prototypes and C++'s klunky "traits" stapled on (traits are meaningless when you have either manifest types like scripting languages or type inference like ML). It's implemented in a language that itself manages to be a mismatch to Slate, but I imagine they want to make it self-hosting later on.
Slate has some really nifty ideas, but I've seen lots of nifty ideas come and go. Usually such projects run out of steam when they reach the final hump of getting everything integrated and performing well. Slate looks nice under the hood, even if it has an ugly paint job, but I damn near asphyxiated when I last held my breath on a similar project.
Re:Too obscure (Score:4, Insightful)
Dylan was hardly successful (Score:2, Insightful)
As elegant and admired as Lisp and Smalltalk are, they aren't exactly the most heavily used programming languages available (and I say that even though I love Smalltalk). Just because a language appeals to language designers, doesn't mean it's going to be embraced by the masses of programmers out there in the trenches. And the more of a mindshift necessary to use it, the less likely it will succeed.
People sometimes disparage C++, but it gained acceptance because C programmers could get their work done using it even if they weren't doing OOP programming. Evolution works where revolution fails.
Re:April fools..I hope (Score:2, Insightful)
What happened to simplicity ?
The point is that languages like SmallTalk Self and this those new beasts: ARE SIMPLE.
Look at it from a different point of view! Suppose you may use your favorite language and you are requested to implement a runtime system and compiler for such a language.
Agree full heartly: SmallTalk has a shitty syntax. So has LISP. Why do I say that? Because most people believe you can learn any syntax. But: a lot of people believe SmallTalk is the BEST language
Well, people reading my posts surely have noticed my typos. They are basicly because that story you may have read here on slashdot, that humans can read still good if lertts are mixed and only start and end is ok is very true for me. I proofread 100 times and I rarely see an erro, because the word crashes into my mind
However somehow languages like PERL or LISP or SmallTalk are incredible hard to read for me.
I know everything about smalltalk which I wanted, and I was at least 3 times at the point to write my own SmallTalk just with a different syntax. Why? Because using protoypes and blocks/closures makes programming so much easyer
With refactoring browsers
angel'o'sphere
Re:Prototyping OO is not a great paradigm (Score:3, Insightful)
"Object and inheritance management" is only an issue for those who don't bother to analyze the problem and architect a solution. Slapping together code without understanding the problem is not "prototyping" -- it's wasting time.
Prototypes are for understanding the application requirements, not for "scripting." If you compare prototyping tools to production applications, you are completely and thoroughly missing the point for their existance.
Re:Dylan is technologically successful (Score:3, Insightful)
Can we really make suck a strong claim about a language on its own?
These days, syntax and semantics are all fine and groovy. For any language, you expect variables and functions and such. One huge contributor to making or breaking a language in the marketplace, though, is its library support.
CPAN, the Python standard library, java.*, boost.org,