
Eve: Programming designed for humans - jhund
http://eve-lang.com/
======
iamwil
One of the more interesting parts (to me) about Eve wasn't the interactive
programming or the literate programming, but that it included a database
inside of the programming language. Most programming languages think of a
database as a thing separate to it (I think Smalltalk is an exception).

Hence, they needed language constructs to make it easier to talk to databases.
As a result, Eve was inspired by the Bloom language being researched at
Berkeley, which was in turn inspired by an old language called Datalog. In it,
they take constraints of a declarative language (like SQL) and use it to make
distributed computing a lot easier.

"Our main data-structure was now a tree of tables. Rather than one big top-
level function, we switched to a pipeline of functions. Each function pulled
data out of the global store using a datalog query, ran some computation and
wrote data back. Having less nesting reduced the impact of lexical scope and
cursor passing. Using datalog allowed normalising the data store, avoiding all
the issues that came from hierarchical models.

At this point we realised we weren't building a functional language anymore.
Most of the programs were just datalog queries on normalised tables with a
little scalar computation in the middle. We were familiar with Bloom and
realised that it fit our needs much better than the functional pidgin we had
built so far - no lexical scoping, no data-structures, no explicit ordering.
In late March we began work on a Bloom interpreter."
[http://incidentalcomplexity.com/2014/10/16/retrospective/](http://incidentalcomplexity.com/2014/10/16/retrospective/)

Here's a talk by Peter Alvaro (doing research with Bloom) about it, and I had
to watch it 4 to 6 times to really get everything out of it. He makes a shout
out to Eve at the end
([https://www.youtube.com/watch?v=R2Aa4PivG0g](https://www.youtube.com/watch?v=R2Aa4PivG0g)).

The Bloom guys are the same guys that released the paper to Anna, the KV store
just 11 days ago.
([https://news.ycombinator.com/item?id=16551072](https://news.ycombinator.com/item?id=16551072))

~~~
scriptproof
"Excited, we presented our prototype to a small number of non-programmers and
sat back to watch the magic. To our horror, not a single one of them could
figure out what the simple example program did or how it worked, nor could
they produce any useful programs themselves." (From the article linked above).

As a programmer, I had the same reaction, actually.

~~~
iamwil
That was pretty early on. They iterated a couple of times thereafter.

~~~
ibdknox
yeah, that was a very early version that we never released publicly, but was
effectively a cleaned up version "Aurora," which I presented at Strange Loop
once upon a time ago.

------
jacobevelyn
In case you missed it, this project is no longer being actively developed:
[https://groups.google.com/forum/#!msg/eve-
talk/YFguOGkNrBo/E...](https://groups.google.com/forum/#!msg/eve-
talk/YFguOGkNrBo/EozaCfheAQAJ)

~~~
mcfunk
Thanks for linking this. The community response is quite something.

"Even the short amount of time I wrote Eve taught me that programming doesn't
need to be so complex.

If Eve didn't come along I wouldn't have believed you could program without
loops.

If Eve didn't come along I wouldn't have thought twice about why all of the
different layers of the stack communicated and passed data around in different
ways.

If Eve didn't come along I wouldn't have believed you could just programming
the happy case, because the runtime would run only the blocks of code that
work with your state.

Rest assured that rethinking and reimagining programming has a bigger movement
now than when you started and you helped drive it.

Ruben" ([https://groups.google.com/d/msg/eve-
talk/YFguOGkNrBo/r_S9hNc...](https://groups.google.com/d/msg/eve-
talk/YFguOGkNrBo/r_S9hNcVAwAJ))

~~~
kbd
> If Eve didn't come along I wouldn't have believed you could program without
> loops.

What's he referring to here?

~~~
RubenSandwich
Eve doesn't have loops, because the basic unit isn't a variable but a set of
variables. So a computation is applied to every element in a value.

e.g.

x = [1, 2, 3]

x + 2

// x = [3, 4, 5]

I have since learned that APL does something similar, expect their basic unit
is an array.

------
hacker_9
Thoughts on why this project was dumped by investors:

I think the problem they really had from the beginning was they were
pressuring themselves to innovate in an industry that is already decades old.
You can't raise $2 mil and not feel the pressure to perform, and sadly this is
not how innovation works. So instead they kept releasing prototypes that
didn't really make sense or remotely scale:

\- turning sql into graphs that made a 2 line statement take up the whole
screen

\- the database language that had no performance characteristics at all

\- the bouncing ball demo that seems to only be made to create a bouncing
ball, and yet doesn't add more understanding to the process anyway

\- the imperative language written in 'english' (but of course only accepts
the english words and specific grammar the software understands) and so on.

Not trying to be harsh, but this is probably a good thing. Once they take a
break and move on to other things, a ton of ideas will no doubt come flooding
in, just because they aren't under the same scrutiny and pressure anymore.

~~~
zubairq
As one of the investors I think it is strong language when you say "dumped",
and not really true in my opinion.

You have to remember that there are still many people who want to back this as
a project. One of the big issues is that it is a really hard problem
technically to solve with many "unknown" "unknowns".

And yes, I agree that many ideas will flood in because of this, and Chris
Granger and Rob Attori and co have already influenced many other people and
projects, they are in my opinion the thought leaders in this new programming
space, and as a consequence have already influenced the entire industry with
their ideas.

In any case, they influenced me, and if they influenced just one person, that
is enough for me :)

~~~
canada_dry
I had only just learned of Eve through this post, and watched a bunch of
Chris' videos... I was blown away by him!

I've been in tech a long time and have known lots of extremely bright people.
But, I've not met many who exhibit such a broad horizontal grasp of complex
technical concepts combined with an elegant and concise way of expressing this
knowledge (e.g. via Eve).

I'd surely bet on this guy again.

------
JasonFruit
I was just reading about Light Table's denouement and how Eve was in a way its
successor, and now I find Eve has gone about the same way. It looks like both
projects foundered because the problems they addressed --- representing code
in non-linear ways with changes live-propagating through the system's state
--- are very, very hard, apparently harder than Chris et al. realized.

In retrospect, their harsh words about our current languages and tools
representing a 1970s mindset come across as hubris.

~~~
dragonwriter
> In retrospect, their harsh words about our current languages and tools
> representing a 1970s mindset come across as hubris.

Nah, I think the hubris is thinking you could make a business with a near-
horizon payoff fixing the problem they accurately identified.

I can't think of any “build a new language” startups that have succeeded (I'm
sure there's one out there somewhere, though.) Getting a language established
is a long slog, unless you've got a mega-user as a partner from day one, which
mostly happens when the project is developed internally by that mega-user.

~~~
currymj
definitely not recently but I think MATLAB, Mathematica, S, Stata, and lots of
other commercial scientific/numerical packages could qualify.

it may not be possible any more, though.

------
aarpmcgee
This is no longer an active project...
[https://twitter.com/with_eve/status/956258695049981952](https://twitter.com/with_eve/status/956258695049981952)
Odd that its not mentioned on their site though?

~~~
hacker_9
Maybe they haven't accepted it yet. Though their blog posts were always few
and far apart.

------
dragonwriter
Eve was a great idea, I’d love to see a community take it up after the
business behind it folded. (I think v0.2 was the last version with the whole
stack that had been built to that point working; v0.3 had engine improvements
but I don't think ever had the dev environment, and v0.4 was a complete
rewrite in Rust that I don't think ever got to a releasable state, though
there were some demos before they went mostly silent for a while and then
closed up shop.)

~~~
ModernMech
v0.4 was missing documentation and some other habitability improvements, but
in its current state it was by far the most useful Eve. You can download it
here if you want to try it out: [https://github.com/witheve/eve-
native](https://github.com/witheve/eve-native)

------
smt88
I'm a huge advocate of bringing usability/ergonomic considerations to
programming languages. That said, I have strong opinions about syntax
decisions that hinder those goals.

For example, writing out words instead of using symbols is easier to
understand at first glance, but it's much harder to skim (even after becoming
familiar with the language). SQL is a really hard language to skim. Of course,
the opposite end of the spectrum (C is close) is also hard to skim.

~~~
seanmcdirmid
So is APL easy to skim?

~~~
munificent
You're being snarky, but I think there's something to the parent comment.

I like the idea that most of the words that someone sees in a program are
words in the domain of the program itself — its nouns and verbs — and not
words in the domain of the underlying implementation language.

For example, though I visually like the way Ruby's "begin" and "end" look for
delimiters, I think braces are better in that they reduce the "word clutter"
of the code.

You can probably take this too far. I wouldn't want to use punctuation for
control flow. But perhaps that's an argument that, like Smalltalk, control
flow should be an API and not built in syntax.

~~~
seanmcdirmid
Syntax highlighting usually is used to set apart the language's keywords from
the rest of the program. They become less like words and more like standard
symbols.

~~~
munificent
Great point! One of the things I really like about syntax highlighting is this
separation. It's important enough that when I'm toying with syntax for my
hobby languages, it's _really_ hard for me to get a feel for how something
looks if it isn't highlighted correctly.

------
everdev
I love this idea. I've always thought the disconnect between documentation and
code felt a bit repetitive.

Why not write a Markdown doc that compiles to code? Especially with a system
like Rails, where so much can be auto-generated. Obviously this isn't for
mission-critical or new ideas, but for putting your CRUD app into the world,
it makes total sense.

~~~
pcnix
This particular part of it isn't a new idea though, it's literate programming,
been around since Knuth.

~~~
cmontella
Literate Programming as put forth by Knuth always involved a "tangle" process
in which source code and documentation is formatted into a literate document.
This is due to the forced order of statements compilers impose on most
programming languages.

What was different in Eve was that the entire language was unordered, and thus
you don't need a tool-chain to read literate source -- the raw source itself
is literate.

~~~
zenhack
Yeah, I've seen a fair bit literate code that is awkwardly structured to
satisfy ordering needed by the underlying language. It works better in
languages that don't care about the order of declarations, of which there are
many, but usually there's something at the top to the effect of "we need to
start off with a pile of imports, because compiler."

Haskell will recognize a .lhs extension and do comments by default, using > to
prefix lines that are actual code (looks block-quote like).

Frankly I am something of a skeptic of literate programming. In most of the
literate source code I've read, the code is clearer than the prose anyway, and
having every detail in comments just makes the whys and the high level design
harder to find.

My approach is to basically assume the reader is familiar with the language
and the key libraries, document the whys, overall design, and the api
contracts, and try to pick good variables and write clear code. This is not to
say "inline comments are bad," but I find that usually when I find myself
writing a lot of comments explaining the details it's because I'm writing a
lot of confusing code.

------
grzm
Discussion from original release in 2016 (nearly 400 comments):
[https://news.ycombinator.com/item?id=12817468](https://news.ycombinator.com/item?id=12817468)

------
_bxg1
The IDE has some interesting ideas but I'm not convinced that the language
itself is actually particularly intuitive. I would love to see a JavaScript
IDE (Atom extension?) with features like

\- "Prose-style", where comments are a first-class citizen and code lives
inside blocks. Seems like this would go a long way to encourage thorough
commenting.

\- The checkbox-style thing, where you can easily mix different pieces from
different files on the screen at once. That was incredibly slick. The general
idea of abstracting code constructs away from the literal files they live in
is something that's been bouncing around in my head for a while.

\- The state export was pretty cool, though it's not clear to me that could
easily be implemented without controlling the language itself.

------
jdbernard
> An IDE like Medium, not Vim

Sorry. You lost me here. If you don't understand _why_ so many developers are
so committed to Vim, then I don't believe you understand how actual developers
(not beginners) interact with code well enough to replace it.

~~~
abritinthebay
Having been a programmer for 20 years I have no idea why so many developers
are so committed to Vim (other than it is available almost everywhere, which
is helpful when doing things on a remote server).

I'm probably going to get down-voted to hell for this opinion here but it's
literally the least productive, least intuitive, and most frustrating editor
_I 've_ used.

But "learning curve" it's advocates cry! The time I have to spend getting up
to speed with vim is better used _actually programming_ , not to mention the
people I know who are advanced users don't appear to code any faster than I
do. A couple of occasionally used text operations are faster perhaps (though
in modern editors it's debatable) but it appears to not have much cumulative
effect.

As far as I can tell the only reason developers use vim _is because developers
use vim_. It's a tautological tool.

~~~
jdbernard
Are you actually interested in having a conversation about why developers
(like me) use vim? I've also been a programmer for almost 20 years. For me
Vim+unix has outperformed VisualStudio (6-through current), Eclipse (and
multiple derivatives), NetBeans, Xcode, and lots of smaller, language-specific
IDEs.

~~~
Bizarro
Are you outperforming with Vim, or is Vim outperforming over those other
editors/IDEs?

I doubt you'd be "outperforming" if you were writing Java in say Vim, over
Eclipse/Intellij...which have vi-keybindings.

~~~
jdbernard
> I doubt you'd be "outperforming" if you were writing Java in say Vim, over
> Eclipse/Intellij...which have vi-keybindings.

That's exactly what I'm doing.

\----

 _edit_ If you're actually interested in a discussion: what does your IDE
actually give you in Java?

* Syntax highlighting? Every code editor (including Vim) gives you that, especially for such common languages as Java.

* JavaDoc access? Cool, but not worth the overhead. I've got the JavaDoc up in a browser pane on my second monitor, easy to search, doesn't make typing laggy or crap all over my text editing pane like the IDE does, and isn't triggered until I actually _need_ the JavaDocs. I've found that by looking them up myself and not having autocomplete I actually internalize the documentation better, which means I need it less. My brain is much faster at autocomplete than the IDE too.

* Automated variable rename. Again, cool. This is one of the few net benefits. Doesn't out-weigh the rest. And silver surfer/grep + Vim gets me 95% of the way there. The only real trouble is when you have lots of duplicate names for un-related things, and that's a bad pattern I'm try to eliminate in my code anyway.

* Debugger? This is a powerful tool, to be sure. But it's not IDE-only. And I've seen it abused. I've never been anti-debugger, quite the contrary. I love my debugger. But I've noticed that as I've gotten older and have developed deeper experience I use it less and less. In fact, I don't think I even have a debugger installed on my work machine right now!

* Automated refactor/etc. I'm convinced this is the _cause_ of bugs more often then the fix. Certainly for poor architectural decisions. I've elaborated in other comments, but basically: train your brain.

That last one I'll emphasize. I don't want the IDE doing any of my thinking
for me. It doesn't _think_ it applies canned patterns which may or may not be
appropriate. Certainly it can be used well, but the more you use your brain to
do it the better your brain will be. And if you train your brain it will be
accustomed to doing the work so that the value lives in _you_ , not your IDE.
Now it's language-agnostic. Now you can jump onto the next cool language
without being hobbled by the lack of IDE support. Now you are forced to learn
the details of all the tools your IDE is wrapping for you and are more
prepared to actually solve problems with, for example, your build environment.

Of course, I'm not saying that it's a binary your brain vs the IDE thing, but
personally I find it more productive to live outside the IDE all the time.

~~~
discreteevent
No. The top feature of an IDE is the call tree: Show me all the callers of
this function and all of their callers and so on. This is a game changer. It
means that you can reverse engineer someone else's code (or even your own).
And in practice, that's what your spend most of your time doing if you want to
make changes that are congruent with the whole system. Eve claims to have
tools to help with this despite not being statically typed. If I get time I
would like to try it because the querying and matching parts of the system are
very attractive.

------
norswap
I think it's very strange that it isn't actively developed anymore. It had
some really gushing reviews. What's keeping people from taking over the
implementation?

------
mamcx
The thing where this fall apart is try to get away from imperative,
predictable code.

That will NEVER (ie, to be on mainstream) work for large scale software OR
attract non-experts.

Try to make a "virtue" a "callback-hell" with other names is a futile idea
(apart some specific scenarios). If is hard to debug, is hard to have a mental
model of it, period.

\---

The other parts of the idea sound well, but is not clear how the magic is made
or how create the "data store".

------
Roboprog
One problem with literate programming: a large portion of the industry hates
to document, and thinks that comments are EEEEVIL. Not me, but many.

I would love to see something like literate programming become more
mainstream, though. Even little things like having to repeat parameter names
in a block above a function/routine, rather than simply next to each
parameter, seems like it’s harder than it ought to be.

------
GrinningFool
The action-response mechanism reminds me of the Easel programming language:

[http://www.eslsyndetic.com/Documentation/overview_of_respons...](http://www.eslsyndetic.com/Documentation/overview_of_responses_and_their_uses.html)

It was a cool model, if a bit ahead of its time. Good to see the idea living
on.

------
weatherlight
it looks (superficially) a lot like Elm.

~~~
acobster
It's more in the logical programming paradigm than the functional paradigm,
IIRC.

------
amelius
Is this related to the eveonline game?

~~~
Sohcahtoa82
You could have clicked the link and found out for yourself in like 5 seconds.

------
matte_black
I really don't understand projects like this. Why can't people just _learn to
code_ , in an actual programming language? To me this is like instead of
teaching people to read and write you teach them to draw pictures and use
emojis instead.

~~~
marshray
This is something you posted 15 hours ago:

[https://news.ycombinator.com/item?id=16625687](https://news.ycombinator.com/item?id=16625687)
> No Klik & Play?! It was the reason I can say I was building and distributing
my own games back in 5th grade! > No Lego Mindstorms!? I was building Robots
with six degrees of freedom in middle school!

I think you, in fact, do understand the value of human-oriented programming.

~~~
matte_black
I’m not sure if I’d generalize my own experiences to the general public. Even
though I used simple drag and drop interfaces to create programs before, I was
also tinkering with HTML and JavaScript, so they weren’t a gateway to real
coding. My time spent with actual programming languages greatly accelerated my
learning.

I’d argue that programming languages are already human oriented, it’s not like
we’re putting together programs with assembly or binary code like some people
imagine. And syntax and conventions improve all the time to make it easier.

If you want to be able to simply speak a program’s requirements and watch it
happen, there’s already a solution for that: hire a coder.

~~~
nkrisc
> If you want to be able to simply speak a program’s requirements and watch it
> happen, there’s already a solution for that: hire a coder.

If everyone had this attitude we'd still be traveling between cities on foot.

Based on their demo, it appears the purpose of the language was to push the
"human centered" aspect of it even further, and not to settle for what's
possible today.

