[E-Lang] beginner reactions

Darius Bacon darius@accesscom.com
Sat, 16 Jun 2001 19:54:25 -0700

I went looking for reactions to E in a private IRC channel for Java
hackers.  Below is the transcript of them checking it out, in hopes
this is useful data, though the main guinea pig turned out to have a
broader background than I'd hoped.  Posted with permission, with
irrelevant conversations edited out.  Anyone who has questions for
them or wants to contact them, let me know.

> pretend you've just heard a tip that it's a `neat language maybe useful' and you're checking it out for yourself
<arete> hehe
> so you download, read docs on the web, etc.  c'mon!
<arete> it combines the worst aspects of pascal and C imho =P
<arete> {} blocks and := assignment
> well, that sort of reaction is exactly what I want to hear about
<arete> hehe you want the uneducated, I just looked at it and thats what I pulled out of my ass? =)
<arete> I can do that
> I would prefer the uneducated, I downloaded it and just messed with it -- but if that's all you can manage, that's worth knowing, yes
<arete> the implicit line ending isn't very nice
<arete> my lines often run over and I don't want to be typing \s
> I've never seen a \ in real e code
<r0khome> demoncrat: you wrote E?  or?
> no, but I'm joining the project
> and the syntax is not finalized yet
<arete> make it like python!
<arete> no {}s
> gee, python needs \ too
<arete> thats ok
<arete> I'll trade many {}s for a few \s
<arete> heh
<arete> r0k: I think the syntax is elegant... I think the OO part is hacked on and icky and the libraries are not OO
<arete> I don't enjoy typing ___INIT___ =P
<r0khome> arete: well... at least python's OO forces you to explicitly declare 'self' rather than have it just magically appear like in java ;)
<arete> heh
> all right, thanks for the feedback - is that everything?
<r0khome> looks kinda lispy too
<arete> demon: I'm only 1/4 of the way through =)
<r0khome> without the parenth's of course
<arete> the walnut
> ok
<arete> my initial thought on the space between object and message is that it is icky 
<arete> I dunno though, this language might not be appreciable if one hasn't been outside the c/c++ world much
<r0khome> nah, that's not icky... who needs periods anyhow?  extra punct  ;)
> I'm logging this, assumign that's okay
<arete> so is a space, but a spaces doesn't tie things together
<arete> demon: sure heh I don't mind
* r0khome remembers smalltalk uses spaces too
<arete> just don't use my name =P
<arete> r0k: Yeah thats where I suspect it was from
<arete> I'd complain about the 'maker' pattern, but it seems kinda nice actually
<arete> but very un C++/Java
<r0khome> hmm... i like this...  'Functions are really objects with a single method, "run".'
<r0khome> and i like this "3 add(4) is identical to 3 + 4" ....   makes me wanna launch squeak again ;)
> heh
<r0khome> def frozen := editable snapshot ...    lists allow snapshots, huh?  hmm... does that copy the entire list?
<arete> demon: I don't grok this part: In Java, delegation is extremely painful to use (since every method must be forwarded explicitly)
<arete> you don't have to forward unless you override the method..
<arete> er perhaps it is because they aren't related in any way heh
<r0khome> demoncrat: E looks good to me... but mainly just makes me want to use smalltalk again (the smalltalk'ish features are the features there that i like)  ;)
> arete - they mean when you make an object that forwards each method to another object (or most of the methods)
> like the Decorator pattern, for example
> iirc there's a fair amount of that in the GoF book
<arete> demon: yeah
> r0k - cool
<arete> I got confused by the lack of inheritance =)
> arete - the party line is, it does have inheritance :)
<arete> right, but delegation can be used wtihout it
* demoncrat nods
> I'm holding off on any major arguing-back I might do until you're done
> (complaints about the book would be good, too)
<luke_> dc: btw Joe's complaints were that it all seemed very confusing and fancy-languagey (the book), and particularly complained about the name "granovetter diagram" for some reason or other.
> luke - e in a walnut?  or the docs on erights.org?
> I'm guessing the latter
<luke_> Ode I think
<luke_> my complaint is that after reading all the docs I could find I still don't really have much of a feeling for it - I can't tell if it's something profound, or just a fancy way of describing something trivial. which is to say, I don't understand it
> personally I think the logo they made out of a granovetter arrow that looks like a lambda is extremely cool :)
> I had to reread it all closely myself...
<luke_> heh yeah nice now you mention it :)
> but I like the writing style on that site - nice and meaty once you dig in.
<luke_> dc: t'would be nice if there was one document that one could read once and get an appreciation for the thing..
<luke_> yes but there are lots of scattered and partially-written-looking documents there and its hard to find a starting place. I suspect the best way for me to figure the thing out is to try implementing their digital currency example in straight erlang and see where I get stuck :)
> since that example doesn't use distribution, I expect it won't be hard
<luke_> well, then is there a better example that does something that would be a bastard to do in non-e?
<luke_> I guess that's the real test, right? there should be some program that they do elegantly but that I can't implement similarly in erlang?
> hm, not quite, since erlang is almost the closest thing out there
> (Oz is the closest)
> er, mozart it's called now, I think
<luke_> hm OK so is the distribution e's big feature? I assumed there was something profound hidden in their cryptographic object references or something
> secure and efficient distributed programming is the slogan
> maybe toss an odd robust and persistent in there too
<luke_> ok.. and the idea is basically continuation-passing-style for messages?
> no, I wouldn't say promises have much to do with cps
> erlang doesn't have promises, as I recall it - does it?
<luke_> not natively
<luke_> promies as in future as in pass-value-around-and-then-block-when-using-it?
> I would say if you took erlang, stripped out some bits (like global process namespace), and added promises and a secure comm protocol (including the 3-party introduction) you'd have much the same abilities as e
<luke_> oh.. so I have lots of distributed interactions amongst all my programs but they only synchronize at the points that they absolutely have to?
<arete> def myLabel := E call(<swing:JLabel>, "new(String)",["label text"])
<arete> thats so crufty =P
> not block when use it
> arete - that's out of date, iirc
<arete> the whole <uri:name> thing is kinda icky
<luke_> dc: then what, turn myself into a promise?
> they do it better now
<arete> ahh good
<arete> demon: the more I look at this the harder it is to hate it =P
> arete - well, it still has uri's but you don't need the E call(...) crap to invoke that sort of method
<luke_> dc: maybe I'm starting to understand (or just get confused :-)), is the idea that you build this big graph of promises and then somehow collapse it as need be? like some kind of distributed lazy evaluation?
> luke - if you force a promise that's still unresolved, you get an exception
<luke_> well am I getting warmer? :)
> luke - most often you use the when-catch pattern to schedule something to happen when the promise is resolved
> mmmm, distributed data dependencies might be a better term than lazy evaluation
> arete - heheh
<arete> def byte := <unsafe:java.lang.Byte> TYPE
<arete> def byteArray := int[300]
<arete> intArray[0] := 3
<arete> demon: how does that create an array of bytes?
<arete> I don't see how the bytes are related to that array creation at all..
<luke_> dc: well ok, but do I end up with a big graph (granovetter diagram?) with various distributed dependencies, and then as they resolve I get to take more steps, and so on?
> arete - weird, lemme find that
> luke - yes
> luke - of course, you can do stuff with promises as long as you don't need the value immediately, but you know that
<luke_> ok, so where does it say that this is what it is? I'm probably better prepared to read it now :)
> arete - looks like the author made a braino
<arete> should be byte[300]?
<luke_> dc: does sound like an idea worthy of a new programming language :)
> arete - I guess it was int arrays originally and got misedited
<arete> ahh
> luke - see the elib section off the main erights page
> start with `concurrency'
<luke_> dc: so are you still soliciting ignorant complaints btw? :)
> yup!
> luke - I'd like to cc this to interested parties if that's all right with you too
<arete> whats this whole 'erights' thing?
> arete - hm, reading this I see the purpose of that section with ``E call(...)'' was to explain that you could do that -- and occasionally you still do need to when invoking java code with overloaded methods - so what's changed is that
> you need to do that less often
<arete> yeah
<arete> ahh ok
<arete> hmm this jpanel qauasi parser is nice
<luke_> dc: my ignorant complain is that the "overview: concurrency in E" doesn't so much give an overview of the concurrency in E but rather bashes multithreading and says event loops are good. I think it would be much nicer if it explained what you've just explained to me :)
> an eright is some electronic service or thingy you own
<arete> ahh
> luke - all right - keep reading, please :)
<arete> demon: you caught me at a vulnerable moment
<arete> I should be studying
<arete> but now I'm gonna be stuck on this =P
> arete - sorry, this has been valuable - oh, okay :)
> anyway, the idea is we'll be able to trade erights over the net, and automatically with your agents programs, etc.
<arete> demon: yeah I like the whole distributability thing
> even with people you don't trust
<arete> I bet I could make a really nice irc bot with E
> E actually came out of a kind of mud network project
<arete> ahh, neat
> which unfortunately died - it was commercial
<arete> a veritable cyberspace of little erights?
> it was ahead of its time
<arete> well I think the idea of erights is too 
<arete> we are just barely getting 'web services' and I don't see them really being useful for years =)
<luke_> dc: well I've read as far as I realistically would when browsing a new language :) and it hasn't told me what you told me. it talks a lot about other systems.
> I think the time is nearly ripe, actually, and we'd better hurry if we don't want worse stuff to take over
> luke - okay
<luke_> dc: so this distributed data dependency business is the main theme? or around equal with the security / privileges aspects (which are still a little mysterious to me)?
> luke - the main marketing document is supposed to be the walnut one anyway
<arete> demon: amen, ever seen soap? =P
* arete has been messin with it today, ewwwww and iiiick
> luke - I think the point is that if they did concurrency with threads, it just wouldn't be practical to distribute programs that way
<luke_> dc: well right now the idea of building things as distributed dependencies seems a very interesting one indeed :) but in the 2 hours or so I spent reading E stuff last time I didn't catch on to that
> especially with mutual suspicion
<luke_> dc: I wish they'd say that "that way" is up front though :)
> see, erlang was designed assuming the whole system was written by one cooperating team
<luke_> I mean, I already know that java's threads suck :)
<luke_> dc: right, erlang is not suited for this. but the E thing seems pretty simple right? basically they pass out unforgeable opaque object references, and I guess the main reason for the crypto tricks is so that the reference can be decoded without any other context?
<arete> demon: there an emacs mode? =)
> arete - sorry, I don't think so
> arete - think of it as a hacking opportunity - I'd like to have one :)
<arete> well there is a good reason not to use it =P
<luke_> dc: well I'll stop whining and have a better read of the stuff when I have time, should stick to Real Work for now :)
> arete - yeah, true
<arete> demon: I _hate_ win32 installer apps
> luke - yes, basically it is just opaque object references
> luke - thanks!
<luke_> actually I'm often happy when ad-hoc languages use C syntax for the very reason that I can edit them in emacs :)
> arete - I've only installed it in linux...
<arete> for win32 you have to run a setup program apparently
> hm, I should try c-mode on it
<arete> I do not like that all, should come in a zip all nicely packaged =P
<luke_> dc: well I think that reading the docs last time gave me the impression that there were more fancy elusive concepts than infact there are, and I sat around being confused about that instead of understanding what its really about.
> arete - I wouldn't know anything about that
<arete> hehe
<luke_> dc: so are you upping your involvement in E nowadays?
> luke - problem is, it actually does look fairly deep
> it's the simple things that trip us up
> yeah
<luke_> dc: but at least this distributed dependency business is something fun to think about and is not particularly confusing. seems a good foothold :)
* demoncrat nods
> I did point you at that pipelining page first last time :)
> c-mode is pretty worthless, alas
<luke_> dc: well, obviously I didn't read it properly. :)
<luke_> so are granovetter diagrams overloaded to show a "trust" and "where privileges can go to" aswell as "computational dependencies", or ?
* r0khome is in the process of installing oracle on linux at home :/
> r0k - what fun
> luke - trust is a slippery concept
> luke - but I'll agree with ``where privileges go to'' if by privileges you mean capabilities
<luke_> dc: right, but until just now I had interpteted granovetter diagrams as showing where privileges get to, but the pipelining page is using them to show dependencies
<luke_> so is there a "one in the same" there somewhere? a promise is an object is a capability?
> a promise is a reference to a yet-unresolved object
> an object is a set of methods that share a state
> a capability is an object that grants some kind of authority to anyone who has a reference to it
> as opposed to an object that just computes a value given a set of inputs, for example
<arete> heh
<arete> I can't get it to install
> so an object that tells you what time it is, that's a capability
> oh damn :)
> which version did you get?
<arete> latest
> 0.8.9t?
<arete> .1
> what happened?
<arete> get an error when I run it
> the setup program?
<arete> yeah
> luke - or, of course, an object that can withdraw money from your bank account
> what's the error message?
> not that I'm likely to be any help
<luke_> dc: well this time I understood the example on the pipeline page and things seem much clearer, thanks
> welcome
<arete> ok there I got it..
> brb, dessert
<arete> heh this is quite likely the worst installer I've ever seen
> ouch :)
<arete> but it works
<arete> I wrote my first e function
<arete> it took 2 screens of trying
> hurray
> heh
> hm, could you mail me those screen?
<arete> hehe thats embarassing
<arete> its nothing I should have done if I was paying attention
> that's perfect!
> I promise not to give your name out
<arete> hehe
<arete> ok I will because your error messages need serious owrk
<arete> email addr?
> darius@accesscom.com
> see, we want this to be popular, so it's got to go well when someone only mildly interested and not trying hard goes at it
<arete> heh
> er, that might have sounded a bit patronizing
<arete> only a little =P
<arete> ok there ya go
> sorry - and thanks
<arete> hmm elmer is neat
<arete> I loaded it but I thought it was a text editor, so I closed it
*** You have new email.
[see http://www.accesscom.com/~darius/e/beginner-errors.gif]
<arete> who would have figured it was waiting for a ?
<arete> I just typed "HELP WHAT DO I DO?!"
<arete> like someone in ed for the first tim
> oh, right
> heheh
> I guess it should come up with a ? to start
> at least
<arete> demon: I can't figure this jpanel quasiparser out =/
> I haven't done any gui programming.  what's wrong?
<arete> ? ? ? ? ? ? # problem: unrecognized: p
<arete> #
<arete> #   <import:org.erights.e.elang.interp.Thrower>(unrecognized: p)
<arete> #   <lexPanel>("${0}.Y     >              >\n\ ${1}                ...1.X\n\ V
<arete>                        ${5}          ${6}")
<arete> #   <JPanel__quasiParser> valueMaker("${0}.Y     >              >\n\ ${1}
<arete>              ${2}         >\...          ${4}  pad1.X\n\ V
<arete>    ${5}          ${6}")
<arete> #   <interp> evalPrint(e`define composedPanel := JPanel__quasiParser valueMaker(
<arete> "${0}.Y     >        ...ListMaker run(explanation, label, field, okButton, cance
<arete> lButton, pad2, logo))`)
> I can't really parse that over irc
> what was the input program?
<arete> hehe
<arete> JPanel section of ewalnut
<arete> but it requires definition of many variables
<arete> couldn't figure out how to run it in elmer either
> I'll try it out
<arete> k
> weird, I don't see any p there
<arete> think its some sort of internal thing
> the language is still in flux, so the book has trouble keeping up
<arete> *nod*
<arete> hmm
<arete> that small queue package is rather different
> it's rather like some Scheme queue code I've seen
<arete> ahh, rather unlike Java =)
> no!  forget I said that!
<arete> eh?
> scheme is a big turnoff with some people
<arete> I like scheme
> I was kidding
<arete> infact one of my critiques of this is all of the special little syntaxes
<arete> I yearn for simplistic elegance
> oh dear, you're not really the target market :)
<arete> well I am... I write java code all day =P
<arete> and I don't understand scheme at all
<arete> but I once wrote a small elisp function that worked...
> frankly I have not much of a clue what it would take to be popular
<arete> demon: mostly the right timing and a lot of hype
<arete> and not too revolutionary
> just how familiar it has to look is a question
> that's part of why I asked for this evaluation
<arete> demon: if you want my pessimistic view, it won't become wildly popular because everyone is busy learning java
<arete> companies won't let their employees use it because of a lack of hirable talent
<arete> java just happened along as C++ was ending its useful life
> I think java is just too messed up to work for stuff like smart contracts
<arete> oh yeah, there are many many more elegant languages
> so if we can get a killer-app type wave going, there's a chance
<arete> always have been haven't there?
> right
<arete> although the fact that this runs in a JVM is a plus
> the difference is, this one is consciously designed to be acceptable and hypeable (hopefully)
<arete> demon: oh hehe, didn't know that one
> otherwise it would be simpler and more elegant, like you wanted
<arete> ahh *nod*
<arete> well I suppose incremental steps are better than none
<arete> for all its ickyness, java is a lot better than the competition
> it was a real improvement on c++, yeah
> how do I make a cancelButton, etc?
<arete> demon: just make them all strings? thats what I did
> I wonder if that's why it went wrong
> not the world's best error message, of course
<arete> ahh, hehe probably is
<arete> I figured it could just make strings labels or something
<arete> but hey
<arete> <swing:JButton> new("hi")?
<arete> thats my best guess hehe
> ok
<arete> its suppose to be predefined... but maybe it isn't
> it is
<arete> really? I get an error
> I've just managed to avoid gui programming a whole lot
> using a different version
<arete> ahh
<arete> heh this version must be really broken or something
> dunno
> it's a different version of the language
> they're working on bringing it all back together
> this is why it's not publicized yet
<arete> *nod* I saw some of the big things were missing
> bleah - the jpanel quasiparser isn't working for me either - different problem, though.
> but I'm not interested in gui right now, so screw it
<arete> hehe
<arete> I got it working
> cool
<arete> but it doesn't display
<arete> it was a bad variable type
> I used buttons and labels for all of the variables
<arete> yeah
<arete> did you use E call(?
<arete> for the buttons?
> no - don't need to in this version
<arete> oh
<arete> which version do you have heh?
> 0.8.9t
> there are other differences, though
> I think your version is closer to the book
<arete> ahh
<arete> yeah yours has the major syntactic reform
<arete> whats major about it?
> simplified the syntax by taking out a number of shorthands
> like ``foo bar()'' instead of ``foo bar''
<arete> ahh
<arete> HAH!
<arete> I got it to display
> also the jpanel quasiparser was in a different place I had to find
<arete> however it is empty =P
> heheh
<arete> demon: try cutting and pasting it into elmer?
> arete - I used the `e' command-line thingy under emacs
<arete> yeah thats all that works for me
<arete> I can't get it to run in elmer
<arete> bad thing imho =)
> odd, I haven't seen any different behavior between elmer and e
<arete> ok well back to reading
<arete> demon: can you import arbitrary java packages with this?
> arete - <unsafe:my.java.package.*> 
<arete> ahh hmm this is rather broken
> oh?
<arete> # problem: <UndefinedVariableException: unsafe__uriGetter not in scope>
<arete> same thing as swing
> try import instead of unsafe
> I think the import/unsafe split is relatively recent
<arete> import says it can't find it
<arete> its in the CLASSPATH
> hell, I don't know that older language - sorry :)
<arete> hehehe
> they've claimed they'll have the language reconciled and the docs updated to it in the next few months
<arete> months? ack
> yeah
> I haven't been pushing this as something to use today
> or it'd be too late to base major changes on feedback from guinea pigs
<arete> yeah
> the claim was in private email to me - dunno if it's a public expectation, even
<arete> k
<arete> hmm
* arete reads the concept of "promises"
<arete> demon: what sort of people are working on this project?
> mark miller is the point man on the language - he used to be chief architect of xanadu
<arete> was that the mud project?
<arete> I've heard the name before..
> that was ted nelson's global hypertext network
> world's greatest vaporware
<arete> oh... yeah where everything is linked to everything?
<arete> source code, docs, files, etc/
> they intended to be able to handle it all, yes, as I understand it
<arete> I read about that in a magazine..
> generally it's a very high caliber of hackers involved
<arete> *nod*
> the design-for-popularity and getting it out on time is a direct reaction to what happened to xanadu, apparently
<arete> ahh I see... the article I read on xanadu was quite interesting
<arete> this promise model of computing is very nice
<arete> powerful in an elegant, simplistic way
> I haven't actually used it enough yet
<arete> hehe well thats just my laymans opinion
> simplistic has the wrong connotations to my ear :)
> just simple would be nicer
<arete> hehe ok
<arete> we can call it simple if you lie
<arete> like
> if I lie!  hrmph!
* arete throws some pez at demon
<arete> hmm
<arete> its not really that hard
> I'm lying down for a bit but if you have any other comments I'll see it
<arete> ok
<arete> one thing, I think they should allow "-" in variable names
<arete> I've come to dislike _
> I like dashes in scheme too but I can pretty much guarantee that won't happen
<arete> yeah
<arete> oh well =P
<arete> demon: this isn't the first time you've pointed me at E... I think the key to hooking someone is to make them read the whole walnut
<arete> cause it just looks like another scripting language until you get into the security and distribution
<arete> then its like fireworks =)
> I wasn't actually trying to get anyone to use it yet -- just answering what I was up to
<arete> yeah, I'm commenting for your logs =P
> mm hm
<arete> I looked at it before but didn't read far enough
<arete> so it didn't look very useful