Slashdot Mirror
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."
I prototyped this mail using it
Do not try to read the dupe, thats impossible. Instead, only try to realize the truth
What truth?
There is no dupe
Looks like dylan.
And for the rest of the world? Oh wait, sorry, Smalltalkers are gods among programmers. So foolish of me to think of myself before the Smalltalkers.
True story.
If the new language doesn't support your needs, shut up and don't use it.
Use what is best for the situation and don't whine.
at least you admit it. that's the first step to recovery.
Its fine for small scripts , rubbish for large programs as object and inheritance management becomes a minefield. I'm sure this language will
provide hours of mental masturbation in various academic ivory towers but for those of us who have to code in the real world its not going to rock it.
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.
;-)
I C sea Slates on the C Shore!
Even though, admittedly, this looks is a joke post, I couldn't help but think this the moment I noticed the article: "I don't really need a programming language that hates Catholic, can't grasp the realities of free-market economics, and is determined to write-in Howard Dean on the 2004 elections ballots..."
i think smalltalk++ would be a better approach than inventing a new language. Look at C++: it's backwards compatable with C, so a C coder is already a C++ coder and can slowly start making use of new C++ features.
Do you even lift?
These aren't the 'roids you're looking for.
Slate is a prototype-based object-oriented programming language based on Self, CLOS, and Smalltalk.
From a recent 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?
I hear there's rumors on the Slashdots
Why was this modded down?
Its a valid opinion. If Slashdot is going to claim to be a place of free discussion of all points of view and fight against censorship, then its going to have to practice what it preaches.
But why would anybody use a moon as the logo for a programming language? Is this to differentiate themselves from Sun's java?
BTW, beta release is not really what I do consider as "stuff that matters". Wake me up when an official release will be announced.
cool.
Does it only let you write about a tenth of the program, then let you finish the rest after you've forked over for a subscription or read some ads?
CEE5210S The signal SIGHUP was received.
Who gives a shit about the real world. None of the tools you cubicle-dwelling corporate serfs love so much ever came from the real world. All your programming tools come from research labs -- mere leftovers thrown away by academics once they grow bored of playing with them.
You code monkeys are nothing but low-skilled craftsmen, so when real scientists speak, please sit down and shut up, mkay?
But, anyway, Brian Rice is a asshole, which I know from experience.
Probably one of those hyper-intelligent theoreticians who should best avoid all human contact.
http://lists.tunes.org/mailman/listinfo/slate
I feel sorry for all the people who get asked "Whats the best programming language." and then get asked "What do I have to choose from?" *sigh*
FuckTheFuckingFuckers.com - Post your th
Confusing things like:
:index | newOC addLast: (oc at: index)].
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: [|
newOC
].
"
How could someone argue with a straight face that this gobblygook is progress in programming languages?
looks like "prototype-based, object-oriented" are the new buzzwords in programming languages
it still needs more nanotubes to leverage your ROI while creating on-demand multi-tier dynamic buisness systems creating synergy between individual nodes of your process factoring considerations
I am one of the primary authors of Slate and I *DID NOT* authorize anyone to do such advertising as this (and I believe the post is severely misleading on other levels), as we are CLEARLY not ready for any sort of exposure of this level. Unless you are really specifically interested in an essentially unuseable language, move along and ignore this. Again, move along and ignore.
Thats MY nick..... So, they're saying I'm a smalltalker with a lisp?
:(
Shhhtop it!
[sig]www.masterslate.org[/sig]
And they say its syntax is easier to understand than LISP? I wonder what they're smoking...
HAND.
In the third case you might find out that you can get by with a set of "prototype" objects to copy from and you don't need classes at all. But to actually eliminate classes you will have to find solutions to the other things they do for you like hold the behaviors for the objects (you can put them in the objects themselves, for example) and reflection (Self uses special "mirror objects" for that).
There are several different styles of prototype based languages.
I'm not elitist. I use both Smalltalk and Java at work (in roughly equal amounts) and I'm quite literally four times as productive in Smalltalk as in Java. I don't write four times as much code in St as in Java, mind you, it's just that much more expressive.
So, as a humble programmer, you would do very well to at least figure out why St is so much better than Java.
Sean
For those who are dissatisfied with current language offerings, I encourage you to check out Io at http://www.iolanguage.com/ .. It's small, simple and pretty well planned out.
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
You can't have a civil discussion with a donkey. Donkeys like to think of themselves as rational, but if you observe their behavior you'll find they are anything but. They [donkeys] are full of anger and bitterness, and react with frightful outrage whenever they encounter someone with different views from their own. Even people who think that donkeyism is a reasonable philosophy must admit that most donkeys did not arrive at their point of view through anything resembling a rational process. Rather, they are poorly educated individuals who are lashing out angrily at anything which they perceive to be valued by "intellectual" society. You really shouldn't take it personally. It is the result of an angry and profoundly unhappy psychological condition on their part, not due to you or your scietific and empirical facts.
So what's wrong with Io? It's been around for a while and announced on Freshmeat. Also already has code written in it. Or Lua, which has been around longer. Or, hell, just update one of the Self implementations. Why yet another language implementation other than ego?
It's going to be based on COBOL, but will add the most annoying features of all of the other programming languges, and will leak memory like a firehose through a collander.
That would definitely make it the popular "Brand X" of programming languages. Every C(+, ++, #), LISP, PROLOG, Python, Smalltalk, etc. programmer would compare their elegant creations to Stale's. It'd also win hands-down in any obfuscated code contest.
Hooray. The 433rd way to write "Hello, World!". And it only took a year and a half of development!
Guys, solve a problem. Don't create another way to mimic all the current solutions.
IIRC
Stale Programming Language?
nt
I win! Game over.
Objective C borrows both syntax and semantics from Smalltalk (on top of C itself, of course). It's a nice small language.
Professional Wild-Eyed Visionary
I guess the new meaning of "Troll (-1)" is "I can't detect sarcasm."
Yet another language turns up that claims its virtual parents are SmallTalk, Lisp, and Self...
e ntation /NewtonScriptProgramLanguage.pdf
It would seem that Apple may have had it right ten years ago when they made NewtonScript, the native language of their Newton computers, since that language too claimed SmalllTalk, Lisp and Self as its antecedents.
Having had a brief look though at the documentation for Slate, and yesterdays Prothon, I can't help but feel that Apple did a much better job with NewtonScript and the Newton environment. NewtonScript seems to me to be much more mature and better thought out than these two examples.
As for comments that I read here about prototype-based languages not being suitable for application development and are effectively only the domain of accademics, I say bullshit. Class-based programming really isn't the only method of OO development, and prototypes can be equally effective. Many thousands of applications were written for the Newton, and they all used NewtonScript and its prototype-based object model. Prototypes can usually be used in a very similar way to classes, and most class-like behaviour can easily be simulated.
If you're interested in finding out more about how NewtonScript worked and functioned there reference manual can be found here:
http://www.unna.org/unna/development/docum
For a discussion of prototype vs. class based programming consult Appendix C of the NewtonScript reference manual.
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.
I remember Dylan, as a matter of fact I still have the book somewhere. It was another amalgam of programming language concepts that never went anywhere.
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.
Dylan is technologically successful (a dynamic, abstract, powerful language which produces programs that run as fast as those written in C/C++), though it has not been market-place successful. If Microsoft had put its weight behind Dylan, instead of C#, then I think Java would have been in serious trouble. The Dylan language is considerably more powerful than Java, but built on a small, very elegant extendable core. Dylan is basically a fully object-oriented descendant of Lisp with infix syntax instead of prefix syntax used by Lisp. Like Lisp, Dylan's macro system allows the language to be extended from within itself.
The open-source Dylan compiler, Gwydion Dylan, is still being actively improved by a small group. http://www.gwydiondylan.org
It runs on linux and MacOS X.
The article says they're merging Morphic and CLIM... two of the coolest UIs I've ever used. If they pull that off, the UI at least will have definate win potential.
The person who triggers Godwin's law has lost the argument. And it doesn't work if you do it on purpose.
Purely prototype-based languages don't really compete with their more structured (class-based) cousins, though. One of the main benefits of prototype-based langauges is that they give a lightweight way to create an abstraction - you don't necessarily have to create a class first. This isn't necessarily a pure win. The structure provided by classes can be useful, too. A good language should provide both capabilities, no matter what mechanisms it uses to do that. It's possible Slate does this, I haven't looked.
Another good candidate mechanism for lightweight abstraction is first class anonymous functions, i.e. lambda, as found in Scheme, Lisp, Javascript, Perl (Python got it wrong, unfortunately). Having real lambdas tends to eliminate a lot of the problems which other languages find themselves trying to solve. Although it helps to also have macros, which limits the list to Scheme and Lisp.
Only a couple weeks if you don't have a lot of procedural baggage to get rid of.
"One of these days, someone will write an article about a genuinely innovative language that really exists in usable form, and the eds will reject it because we've all got bored. :-)"
English.
Throw in some of the other OSS work out there and we truely could have a nice WE (Evas, XUL, The new X, etc). If memory serves, Apple was going to do a totally OOP's OS (Imagine drivers done the OOPs way). I think OSS could grab the Darwin kernel (Mach is a perfect fit), and throw something like Squeak on top of it. Set the GNUStep libraries beside it, and you'll have something nice. maybe even a scripting environment on the other side, for the newbies to start with.
This took me by surprise, and I'm not a usual poster here, so I don't have the energy to reply to each person in turn. So I'll summarize some points I've seen:
This post is entirely misleading; we are not researchers, and we do intend to do business based on this language. However, what the language itself is is entirely mis-represented. Note: the original submitter is not affiliated with our project in any way, and in fact does not actually know or use the language.
First, we are not in a project mode of self-promotion or public representation at all. Nothing on that site claims to be a real tutorial, and the current efforts have mostly been about experimentation. We are still preparing the really usable implementation, and have a huge set of ideas and environment enhancements in backlog waiting for this. What's mentioned on the front page is actually a mere fraction of what we're working on.
The project name, "Slate", is short for "Clean Slate Smalltalk". If you don't know Smalltalk, very little of it will make sense; what's at issue is that we mean what Alan Kay would say in that Smalltalk currently means Smalltalk-80, just a certain quirky snapshot of a whole range of ideas that he and others were working on. We're interested in that whole range.
Slate is only about prototypes insofar as this was an initial language stage that was simple to play with and powerful enough to explore without too many limitations. Further revisions of the language will feature higher-level facilities for more type-safe programming and more declarative consistency (declarative in the sense of (re-)defining a class and having its instances track that consistently).
Slate's environment is about 0.001% of completion of what we intend, and we have a huge body of experience and code and ideas to draw upon which are already largely mapped-out. What you see on the site is not representative of what we want in those terms.
The syntax is definitely odd. At issue is the fact that we kept a minimal Smalltalk syntax core and optimized it for "phrase value" and added various annotation mechanisms, which wind up being very hard to understand until you crack open the 40-page programmers' manual which explains this all. Although it is no tutorial, everything is explained there, and improved with feedback from early users.
Slate is eventually going to be a full environment, and be very flexible at a large scale, so that questions of prejudice about design choices will not matter, because we actively take part in designing the system so that users can make the choices: whether image-style live interaction or C-embeddable, highly-optimized, low-overhead, no-IDE deployment. And make it so you can make these choices independently; current Smalltalks, Lisps, Dylan, and hundreds of other languages (especially the more common ones) don't have this.
There are a number of issues brought up here which are addressed but not advertised on the front page; for example, Slate will handle security at the language level, using capability analysis and the subjective programming feature mentioned. Our project has no marketting team (see Smallscript), and has actively avoided public claims until we have the demonstration at-hand. I am giving a presentation and demonstration of the next major release, featuring a self-hosting (C-friendly) setup in Seattle at Smalltalk Solutions 2004 in May.
In prototype-based languages, creation of new objects occurs by copying (cloning) existing objects. After copying, the clone is independent from the original -- changing one has no effect on the other (there is no Inheritance relationship between them).
Inheritance-style call (message) dispatch is handled through a slot named "parent" that every Object has. A call (message) that does not have an object-local slot (handler) is deferred to the objects referenced in the parent slot. In this way, objects can share the same parent and thus the same behaviour (unless locally overridden).
Note that when a clone is made, all slots in the original are copied to the clone, so the clone has the same parents as the original. Of course, after cloning, you can change any of the clone's slots independently from the original, including the "parent" slot.
Prototype languages are really not much different from class-based languages... they just split up the responsibilities a bit differently (and perhaps more uniformily).
There are various articles out there, something like, "ACL2 theorems about commercial microprocessors" comes to mind. Also, Boyer and Moore have no doubt been consultants with a variety of companies. The fact that ACL2 is built in lisp is not incidental, but it is really the fundamental design concepts in the theorem prover that are more important. There are eight gazillion provers and model checkers out there, based on various formalisms. HOL, Coq, NUPRL, and ACL2 are some of the most popular provers. In Model Checking I have only fooled with MONA.
Functional and logic have always been regarded as more advanced, it just took forever for people to come up with solid compilations schemes.
Syntax is only one element; semantics and expressiveness are the keys. An otherwise awesome language with bad syntax can be fixed, as syntax can be tailored easily.
Also, ugly or strange looking syntax can be important. Look up Ken Iverson, who won the Turing Award partly for his contributions to notation.
That wasn't offtopic. It was an unneccesary post and it certainly should have been modded down, but "you fail: it" is psuedo Smalltalk/Slate, and therefore is supremely on-topic.
JavaScript
You read right. JavaScript has a prototype based system for objects. I seldom see this mentioned in language design discussions.
Actually I like JavaScript and it's prototype system quite a lot. It's a nice and powerful little language.
But that's likely only the case because I never needed to implement any cross-browser stuff in it.
A language in which one programs entirely in paradigm shifts, and "sea_change" is a reserved word. Any reference to descendant classes are referred to as frere; their parent classes as pere. I would go on, but Slate isn't as much fun as the other new programming language, Salon.
Heute die Welt, morgen das Sonnensystem!
"Number Of Programming Languages Exceeds Number Of Programmers"
I wonder what Real computer scientists have been working on.
Lump lingered last in line for brains, and the ones she got were sorta rotten and insane.
Wouldn't you have to defined all the things that you could do, and then wait for someone to send you messages telling you what to do next?
Yesterday I wrote a small python script (to learn some of it) and it included this (quicksort):
Here the anonymous functions do see their scope (pivot). However, unlike Perl for example, these "functions" really can be only expressions so in that sense they're more limited as. Just out of curiosity, is that what you meant with "python got it wrong"?Do we need yet another impractical language? Look, Perl started off solving problems in the real world and was then developed into a "real" language. These pie-in-the-sky types all have the same problem, and Larry Wall nailed it. They're inventing a language around some theoretical idea, rather than looking at what works in the real world and gently enhancing it.
Even if the main idea is a great one, the language always sucks because it is too much enslaved to that one idea.
And the funniest part is that the language of the week is always on a web site served up by C/C++ and (Linux|Windows).
If you are looking for a Smalltalk-like language for scripting applications without the Smalltalk GUI, check out GNU Smalltalk. It's a pretty faithful implementation of Smalltalk, and it even has a JIT.
Waste some mod points on me, you stupid slashdot-loving moderator boi!
Lisp - it's not just for homosexuals any more!
The AC parent post probably referred to "procedural baggage" as an obstacle to get advantage of Object Orientation for structuring your code.
It's trivial to code in an imperative fashion with Smalltalk, it's no different than using Python or Java.
---- MISSING MISCELLANEOUS DATA SEGMENT --- [sigdash] trolololol
If you have prototypes classes are not needed. They give no further possible abstraction. If you have only classes prototypes are not needed either, but they provide a lot of power you lose otherwise.
... so the method dispatch etc. is very much done during runtime.
What you likely want to say is static typing versus dynamic typing. Most prototype bases languages are dynamic typed
In case you want to "design" a larger system with a prototyped language, you of course "design" traits objects. They are just the same thing what classes are in C++/Java etc.
Your statement The structure provided by classes can be useful, too. comes irrelevant then, as the structure is the structure of the traits/prototype objects.
angel'o'sphere
Cost free eBook I read (by iBook/Kobo/Amazon/ObookO/Gutenberg etc.): "The Green Odyssey" by Philip Jose Farmer.
Certainly, I agree that there's a correspondence between e.g. classes and prototype objects. However, that correspondence is not exact - if it were, there'd be no difference between the two approaches. However, there is a difference, one of the main ones being what is allowable for instances cloned from prototypes, vs. instances instantiated from classes. It is this point which makes class-based programming more structured than the prototype equivalent, in general.
Traditional class-based systems impose a contract on instances, ... :D
Indeed, I missed that. Thats right, point taken
Cost free eBook I read (by iBook/Kobo/Amazon/ObookO/Gutenberg etc.): "The Green Odyssey" by Philip Jose Farmer.
But then again, in a proto-oo language as flexible as Slate, one could easily impose the same restrictions- each new proto derives from some other one, its parent. You could implement a class-ish system, something that had the same restraints, pretty easily in a language like Slate.
But then again, similarily, in a flexible enough class-based OO language- like Smalltalk- you can add protos incredibly easily. Sure, you could implement a proto-oo system in any language, but in a language like Smalltalk it is incredibly easy and sometimes quite useful.
Working toward a usable PDA environment in the spirit of Newton OS: Dynapad