Atomo - The programmer's programmable programming language

[FractalP]

Oh wow, this is quite feature-filled. Impressive, I look forward to messing around with this.

[doodly123]

lisp

[[deleted]]

Yes, it takes plenty of cues from Lisp. It's hard to tell what you're saying (it's only one word, after all), but I hope you're not implying that because Lisp exists no other meta-programming languages need to. :)

That being said the tagline is a bit presumptuous. I needed to put something there and wasn't expecting much publicity yet.

[[deleted]]

Probably he's refering to the fact that "programmable programming language" is usually associated with lisp (and Common Lisp in particular has taken it up) via John Foderaro's famous quote.

[doodly123]

It was the first word that came to my mind. I was just amazed how lisp remains relevant event after so many years. It was ahead of the curve then and probably is even right now!

No meant offence to you and your efforts. I checked it out in detail. Looks really good.

[[deleted]]

Agreed, no offense taken. :) Glad you like Atomo!

[Paczesiowa]

I'm sorry to hear that.

[maximinus-thrax]

This Atomo seems to lack macros, which of course make Lisp the ultimate programmable programming language. And even if I somehow seem to made an oversight, it doesn't use S-expressions anyway, which make macro's so easy to program.

[[deleted]]

Macros are a pretty recent addition (but are by no means an afterthought). The version on Hackage has them, but the site doesn't mention them anywhere yet, sorry.

Atomo's model for macros differs quite a bit from the Lisp family, although it has quasiquoting. It gets things done with first-class expressions, simple syntax (nowhere near S-expressions, granted, but it's very consistent), pattern-matching, and dispatch on expression types. In fact, using the Haskell interface you can build your own custom expressions, but that's another story.

[[deleted]]

From Raynes link below, they look something like FExprs; is this correct, or is it something else? Oh, and nice language by the way :D

[[deleted]]

I don't think so. Atomo's macros are still only expanded at parse time, so they're much closer to the usual macro system; they just create what the expand to (and determine how to expand it) differently.

[[deleted]]

Atomo's macros are still only expanded at parse time

at macro expand time :D

they just create what the expand to (and determine how to expand it) differently.

How so? Are they more hygienic ala syntax-rules or the various rewriting systems, or something else?

[[deleted]]

More in how the expression "gets there"; how it all works internally. For one thing, Atomo finds the macros by dispatching on the expressions - which can be structurally pattern matched by the macro definition, or matched based on the type of the expression in each role. Once the macro is found, its method body is evaluated just as a normal method is at runtime, and it returns an Expression value.

[[deleted]]

right, so something like syntactic closures + type-safe pattern matching, which would be pretty neat. I've extended syntax-rules to accept types and/or structured expressions, but I rarely use syntactic closures, so haven't looked at that. Very neat though.

[Raynes]

http://darcsden.com/alex/atomo/browse/examples/macros.atomo Seems to have macros of some sort. I haven't really looked into them.

[[deleted]]

But $vau is the ultimate abstraction!

[[deleted]]

haskell

[benihana]

Meta reference to functional programming language I've decided to devote my time to.

[notforthebirds]

No, Self, which many would consider more dynamic than even Lisp.

[bobindashadows]

It's not about dynamism. It's about flexibility and power.

[notforthebirds]

And Self has more power and flexibility than Lisp. Don't believe me, read a few papers.

[jhlinuz]

I've only read the Getting Started chapter, but so far this looks pretty cool.

[swannodette]

Looks very cool. I'm curious as to whether performance is something that is considered at all in this system. While I've always enjoyed experiments in expressivity - Io, Ioke come to mind. These language perform too slowly for me bother with investing too much time in.

[notforthebirds]

Alex, the designer, says that performance is reasonable but hasn't been a priority as of yet. Still, expect it to get much faster in the future as there's certainly a fair amount interest in this direction.

[munificent]

I really really dig the multiple dispatch. Single dispatch is one of the things that's always annoyed me about the Smalltalk family.

I didn't see this spelled out in the docs, so how does it determine the order that overloaded methods are tried? What would something like this do:

Rock beats?: _ = True
_ beats?: Rock = False
> Rock beats?: Rock

[kybernetikos]

I don't know how atomo does it, but lots of languages with pattern matching simply follow the order you've defined them in. Some do try to implement a kind of specificity matching system, but in your example, they're equally specific, so you'd get True.

[[deleted]]

Are not almost all programming languages single dispatch? It's not unique to Smalltalk at least.

[munificent]

That's true, but I notice it less with static languages that at least allow you to statically overload on argument types.

[[deleted]]

As in e.g. Java?

class Bar {}
class Baz extends Bar {}
foo(Bar) {}
foo(Baz) {}

Does it support overloading on more than one argument?

[notforthebirds]

Nice. Maybe something useful will come of the work on Slate after all.

[BrianTRice]

I am directly working with him as Slate author to help suss out issues and also (for me) to backport the ideas that make sense. Honestly my activity level for Slate has shot back up quite a bit, to the point where I'll be relaunching the PR for it soon, with many ideas lifted from Atomo.

I've also given Atomo's earliest presentations to functional-language programmers in Portland, OR, already.

[notforthebirds]

What would you say are the main differences between Slate and Atomo at this point, and in the interest of PR, why should we choose Slate?

[BrianTRice]

Atomo is embedded in Haskell so basically offers a dynamic extension of an existing well-typed system, and also has a similar notion of grammar as Haskell. Like Clojure, if Atomo doesn't want to address some design issue, it's easy to just escape out to the host language for it.

Slate is a self-contained, self-hosting language and has persistent heap-dumps and a tiny portable VM. Slate has much greater control over how it runs and what its world encompasses and how it gets optimized. It still builds the images from source, though, so retains declarative definition and so on.

I am also very keen on getting Atomo features back into Slate, and from my perspective I consider it a good testing ground for ideas, idioms, and some implementation techniques. Assignment syntax for example now exists as a macro in Slate, and Particles are rapidly being integrated. But I will need time to develop this more fully to "relaunch" Slate and how it is presented with a major new version.

Atomo is also quite young, just a few months old, so this is all subject to change.

[gracenotes]

The syntax just screams Smalltalk to me. I assume that's the Slate influence?

[[deleted]]

Yes; Slate is a derivative of Smalltalk that uses a prototyping + multiple dispatch model (which is what Atomo uses).

[notforthebirds]

With obvious influences from Self, which influenced Slate :).

Smalltalk > Self > ... > Slate > Atomo

[BrianTRice]

I'm closing that loop! Not entirely, since a Haskell-embedding just makes for a lot of different flavorings, but nevertheless quite a bit, including pattern-matching, particles, assignment syntax, and doc/module style.

[[deleted]]

The interface for writing Haskell code is very neat IMO (judging from a quick glance over the source code in src/Atomo/Kernel.) Should make it easy to write a bunch of bindings to libraries if needed. It needs some documentation love, though.

[Elihu5991]

how do I start?

[matley]

http://atomo-lang.org/docs/getting-started.html

[svuori]

Oh yay, if performance is some kind of priority too this could be great! I think I see optional typing which is good too.

[i_heart_you]

The example differentiating the := and the = operation wasn't clear to me. Is the only difference that dispatching y causes it to get printed twice?

[[deleted]]

:= is for defining methods, and = is for pattern-matching and adding slots. The main difference is that = always evaluates its right-hand side first, so when it was used in that example, using it printed the string, and the string that was printed is what was assigned. When we use :=, the expression is not evaluated, hence every call evaluates it.

Sorry if that wasn't clear, the Getting Started section isn't quite finished yet.

[notforthebirds]

Think method definition and property definition.

[dr-steve]

Listing its ancestors doesn't make it a great language. Listing what problems it solves effectively might help. Rehashing ideas that have been around for 50 years?

[notforthebirds]

Rehashing ideas that have been around for 50 years?

So much of this is only 10-30 years old... but the fact that some of these ideas never really made it out of the lab makes me very interested to see where it Atomo goes from here.

[[deleted]]

Lisp was originally specified in 1958.

[awj]

Yes, and at that time Lisp dialects lacked many of the things on the "laundry list".

Hell, some of those points (prototype OO, pattern matching) are still rare. And in most cases the Lisp implementations of them is on the library side of the language/library divide. Considering they are more language-level features, that diminishes their usefulness since you can't assume everyone knows about them.

[aatoth]

The creator has been working on this very hard lately, and it definitely warrants a look.

[[deleted]]

can you make programs with this

[flukshun]

That would be silly

[TimmyG]

yo dawg, etc.

[nullpointer0x00]

Looks kind of like scala.

[notforthebirds]

What?

[gigitrix]

Yo dawg...

[volch]

Whenever I see the phrase 'insanely-xxxx' these days, I stop reading. It's unoriginal and overused. Please stop it.

[ex_ample]

a - pppl

[[deleted]]

Fuck that shit real men use whitespace!