gmane.comp.lang.slate.general

2011 New Year's Update

Brian T. Rice — 2011-01-03T21:46:20

Since I've been so publicity-shy the last few years, it must seem like Slate is dormant, but I'll try to dispel such impressions soon and start with some status updates.

Slate is (for purposes of overview) a self-hosted dynamic object-oriented language with prototypes, multi-method dispatch, and a variety of other strong features described at http://www.slatelanguage.org.

VM/platform-side:
The SSA VM is still supporting Slate's run-time well. We've not been regularly updating the 64-bit port of Slate but that is simply due to contraction of build supports (basically, I stick with 32-bit modes out of convenience and we don't have a regular user insisting on 64-bit usage). Other than that, Slate's runtime has remained very portable and stable.

Language:
* Rest-parameters, allowing methods/blocks to receive an arbitrary number of non-dispatching input values (without grouping them in Array arguments), were made possible using sequestering of the comma character from binary selectors.
* Assignment notation has been added, as a macro using a binary selector, but NOT requiring the backtick (`) prefix of ordinary macros. The parser in fact recognizes a class of binary selectors as having assignment-style precedence and expands them into the less-convenient message-passing style that is the basis of Slate abstraction. So we get notational convenience without breaking encapsulation, and without too many special parser rules (macros are just methods on AST node types as usual). Quick examples: "x := y foo: z" => "x: (y foo: z)" and "a at: 3 := 4" => "a at: 3 put: 4". Op-assignment like "+=" is also included.
* Other notations are in development, such as "::=" for immutable/nestable bindings, which will replace a lot of what Slate "define:" does for types and constants. "=:=" is envisioned for two-way unification/pattern-matching of terms.

Libraries:
* Stream / IO performance was increased by an order of magnitude by transitioning the API to build upon the bulk-transfer primitive style rather than element-by-element transfer, meaning that composed streams act faster because they're batching operations by default. This makes parsing and loading Slate libraries quicker, which also improves bootstrap-from-scratch. More in this direction is coming, as strongly informed by Smalltalk's recent experimental Xtreams project.
* Slate's parser was re-structured to be a little more efficient, extensible, and have better stateless stream-style behavior (anticipating a documentation language extension).
* "Pattern" syntax has been added, generalizing symbol syntax #foo with #(foo: _) to allow a few notations from Atomo (described below) such as generalizing `er which expands "#foo `er" to "[| :x | x foo]" into "[| :x :y | x foo: y]", or allowing for full functional-programming-style pattern matches. There's a lot going on with this that is in flux so I'll expand this later.
* Macros named `conditions: and `conditions:otherwise: were added to complement caseOf: and caseOf:otherwise: to allow condition-rule pair checking in methods that is efficient but intention-revealing for code that requires more abstraction support than PMD.
* The Slate file/module notion is taking a page from NewSpeak and CommonJS notions of modules, where file source is used as a kind of strongly-isolated function body that is only aware of its very local naming conventions and which supplies a return value (or side-effects the namespace it is loaded-into) to allow for atomic-loading and relocatable modules, or modules which can be loaded in two different places at once for testing. (This also makes source code less verbose since it uses fewer nested namespaces textually.) I am already parceling out system construction into these independent entities to make Slate's ecosystem less brittle. There will also be a *convenient* library installer soon.

Support:
* Disassembly in the debugger is easier to read.
* Indentation in the Emacs mode is finally sensible in almost all cases, and has kept up with the latest syntax changes.

Atomo:
Atomo is a young language embedded in Haskell that is strongly related to Slate (and evolved through ongoing discussions about desired possibilities for Slate). It uses PMD with a more-sound version of prototype derivation than delegation slots, and also implements input-destructuring and pattern-matching a la Haskell. It is an embedded language so has raised interest from the Haskell/functional community about having a good embedded dynamic language for Haskell as a platform.

I have been engaging in "co-opetition" with Atomo, presenting it at local user groups in Portland for publicity and feedback, and providing experience reports from Slate that help inform design decisions. Atomo in turn has acted as R&D vessel for Slate ideas, which I am carrying back into Slate as quickly as I can. In particular, I will port back Atomo's documentation style (self-hosted, using the parser to embed "live" example code) to make Slate much easier to document, learn, and master.

See http://www.atomo-lang.org

An error while making progman.pdf and a couple of questions

Rayne — 2010-03-13T04:26:35

I git pulled this straight from the github repo, and I'm not a Latex
or lyx guy, so I'm not sure what's wrong here.

rayne< at >rayne-desktop:~/slate-language/doc$ make progman.pdf
lyx -e pdf progman.lyx progman.pdf
unusual contents found: [char " mathalpha][char g mathalpha][char o
mathalpha][char l mathalpha][char d mathalpha][char " mathalpha][char
+ mathalpha][char " mathalpha][char f mathalpha][char i mathalpha]
[char s mathalpha][char h mathalpha][char " mathalpha][char =
mathalpha][char " mathalpha][char g mathalpha][char o mathalpha][char
l mathalpha][char d mathalpha][char f mathalpha][char i mathalpha]
[char s mathalpha][char h mathalpha][char " mathalpha]
unusual contents found: [char " mathalpha][char f mathalpha][char i
mathalpha][char s mathalpha][char h mathalpha][char " mathalpha][char
+ mathalpha][char " mathalpha][char g mathalpha][char o mathalpha]
[char l mathalpha][char d mathalpha][char " mathalpha][char =
mathalpha][char " mathalpha][char f mathalpha][char i mathalpha][char
s mathalpha][char h mathalpha][char g mathalpha][char o mathalpha]
[char l mathalpha][char d mathalpha][char " mathalpha]
Warning: Index sorting failed
----------------------------------------
LyX's automatic index sorting algorithm faced
problems with the entry '˜== (message)'.
Please specify the sorting of this entry manually, as
explained in the User Guide.
make: *** [progman.pdf] Error 1

Also, this link: http://www.slatelanguage.org/doc/progman.pdf is dead.

I've never used a language like Slate before, so I'm not used to the
whole 'image'-based programming scheme. I'm not sure how I should go
about writing my code. Is the entire application supposed to be made
up of evaluated expressions in the REPL? What should be put in files,
if anything at all? The tutorial is quite brief, and the
GettingStarted tutorial is quite complicated, so I'm a little
confused. :p

Finally, how would one write a command-line script or something of
that sort?

Latest news

Brian T. Rice — 2010-02-02T20:42:00

We've been in lurk mode for the last few months, but progress
continues. Here are some highlights:
- The VM was ported from C to C++, allowing some smarter handling by
the VM of Slate pointers, which means that our GC is now precise
instead of just conservative.
- Syntactic support for *rest parameter passing in message sends was
added, by sequestering the comma (",") as special syntax which goes
after optional keywords and the main message phrase. Now, collections
can be instantiated via, say, "Set new*, 1, 2, 3, 3", for example. The
"," selector for creating Points is now named "<>" to avoid collision.
- Various inefficiency fixes which each resulted in a 10-15% speed
gain were implemented. The VM is now substantially faster than a few
months ago.
- A simple inliner (not a JIT) which uses simple type inference to
inline bytecode methods to produce inlined versions of the original
method has been implemented. It is not yet robust enough for
production use; we're still tracking down a bug that rears its head
during bootstrap, and it punts on optional keyword passing.
- Further updates which are still being worked out. I'm working on a
module system inspired by some recent work in Javascript, better
support for concurrency, and trying to adapt the recent "Xtreams"
Smalltalk stream protocol to Slate for better inherent stream
performance.

Presentation at a local user group

Brian T. Rice — 2009-08-28T03:45:42

I gave my first Slate presentation in a few years at the local  
Smalltalk user group, PDX.st. This is a very preliminary slide deck,  
mostly telling the broad story of Slate rather than enumerating  
features in detail. I talked around it, and introduced features via  
full-screen Emacs mode.

I intend to expand on this quite a bit, for the purpose of presenting  
to local Rubyists, Pythonistas, Perl mongers, etc. And of course I'm  
still coding in various ways on it. I think Portland has done me a lot  
of good in that area.

Anyway, let me know what you think: http://files.slatelanguage.org/PDXst2009.pdf

--
http://BrianTRice.com


--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups "slate-language" group.
To post to this group, send email to slate-language< at >googlegroups.com
To unsubscribe from this group, send email to slate-language+unsubscribe< at >googlegroups.com
For more options, visit this group at http://groups.google.com/group/slate-language?hl=en
-~----------~----~----~----~------~----~------~--~---

Making up to $1,000 Everyday On Complete Auto-Pilot!

allegra rocamora — 2009-08-24T01:37:43

Making up to $1,000 Everyday On Complete Auto-Pilot!the fastest system
for you to start earning money online I have ever seen.
http://www.easyinternetbiz.net/index.html
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups "slate-language" group.
To post to this group, send email to slate-language< at >googlegroups.com
To unsubscribe from this group, send email to slate-language+unsubscribe< at >googlegroups.com
For more options, visit this group at http://groups.google.com/group/slate-language?hl=en
-~----------~----~----~----~------~----~------~--~---

Making up to $1,000 Everyday On Complete Auto-Pilot!

allegra rocamora — 2009-08-24T01:37:43

Making up to $1,000 Everyday On Complete Auto-Pilot!the fastest system
for you to start earning money online I have ever seen.
http://www.easyinternetbiz.net/index.html
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups "slate-language" group.
To post to this group, send email to slate-language< at >googlegroups.com
To unsubscribe from this group, send email to slate-language+unsubscribe< at >googlegroups.com
For more options, visit this group at http://groups.google.com/group/slate-language?hl=en
-~----------~----~----~----~------~----~------~--~---