
Eve Version 0 - darklighter3
http://www.chris-granger.com/2015/08/17/version-0/
======
jamii
The change of focus is perhaps hard to understand without more context.
Basically, there are two really different modes of programming:

Most of what we see on HN is about building applications, servers, websites
etc. Big, monolithic things that take weeks to years and are deployed to
somewhere else and used by lots of people. Most programming tools are built
for this kind of work, where the time between writing the code and actually
using it is days or months.

But the people we want to make programming accessible to are mostly knowledge
workers. Their work is characterised by a mixture of manual work and
automation, throw-away code and tools rather than applications. It's better
supported by Excel, SQL, shell scripting etc than by the big languages and
IDEs.

We realised that we can do much more good focusing on that kind of
programming.

~~~
rgoddard
I am currently working as an Actuarial Analyst, but I have also worked several
years as a programmer.

As an analyst the tools I use are excel, access, SAS Enterprise guide and
Oracle SQL developer. One of the big problems I face is that we have no good
way to abstract away a process and really make it reusable.

My general work flow is using SAS to pull data from multiple sources, combine
and run the data through some series of logic/calculations. Then take the
resulting data, copy to excel for some additional analysis or report. This
might be for a monthly/quarterly report or an analysis that needs to be update
with the additional runout of data.

But these steps are all tightly coupled together. If I want to rerun the same
logic on a different data set, or an updated data set I will copy and paste
all of the files, update the queries. I have no way to bundle them together so
that I can easily reuse with different data sources, or refreshed data.

Really want I want is someway to encapsulate different sets of data
transformations/calculations into to functions to reuse them in different
contexts and among different people.

~~~
dgudkov
Look at my EasyMorph ([http://easymorph.com](http://easymorph.com)). It's a
visual replacement for scripted data transformations. People use it to replace
SAS and Visual Basic scripting. It also allows creating reusable modules.
Contact me at <hnusername>@easymorph.com if it looks interesting to you.

~~~
shaunxcode
Hey, I clicked through, read the tutorial, got excited about your examples..
tried to download and found out it was windows only! I would have totally
evaluated it further if there were an os x/linux option.

~~~
dgudkov
Thanks for checking it out! As we're targeting Tableau users so eventually we
will release an OS X version.

~~~
nycdatasci
Speaking of Tableau (which was founded on the concept of VizQL), how is this
different? Doesn't tableau basically enable knowledge workers to create data-
centric web applications?

------
mkozlows
So after they didn't exactly revolutionize the IDE with Light Table, and
pivoted to revolutionizing programming, they seem to have kind of come around
to revolutionizing... groupware? Which at least seems more plausible, as it
ought to be possible to make a better groupware application than Lotus Notes.

I think the larger implication is: Programming tools are actually pretty good,
and the larger process of programming is fairly solid, and while improvements
are possible, they're probably going to be evolutionary improvements that
build on what we have, rather than throwing everything away in favor of a
brand-new approach.

~~~
dgreensp
I get the opposite message, which is that programming tools and the process of
programming are so bad, it's hard to get a computer to do a simple task for
you without tearing your hair out, never mind building a UI. A better IDE
(basically a better text editor) doesn't even scratch the surface.

~~~
mkozlows
The thing is, it's easy to say something is hard. Programming is definitely
hard!

The question is: Is it hard essentially, or is it hard accidentally? That is,
can you remove unnecessary complexity from programming and suddenly it'll
become easy?

That was the proposition behind first LightTable, and then Eve as originally
conceived. But neither of them really found a satisfying answer, a way to say
"hey, for making your web app or whatever, if you throw away your existing
stuff and use this tool/process, now it's super-easy."

That implies heavily that a lot of the complexity and difficulty is essential.
Not all of it -- things will get easier and better over time, as they have
over the last ten years -- but enough so that blowing it all up and starting
from scratch isn't likely to lead to wins.

~~~
dunkelheit
In its essence programming is transforming data (and code is data too).
Everything else is incidental. But if I think of the things I do in my day-to-
day work as a software developer it is 99% logistics (getting data in the
right place and in the right form) and 1% related to actual meaningful
transformation. If my understanding is correct (I only had a cursory glance)
eve attacks this problem from the promising angle by making all data available
in a ready-to-query database.

Still I think there must be some hard lower limits on amount of incidental
complexity. Nature just can't allow you to get rid of all of it (impossibility
results from distributed systems theory come to mind) just as in manufacturing
transport costs can't be zero (goods and materials can't be transported
between factories faster than the speed of light after all). It will be
interesting to see how eve team works around these issues.

~~~
agumonkey
> But if I think of the things I do in my day-to-day work as a software
> developer it is 99% logistics (getting data in the right place and in the
> right form) and 1% related to actual meaningful transformation. If my
> understanding is correct (I only had a cursory glance) eve attacks this
> problem from the promising angle by making all data available in a ready-to-
> query database.

Reminds me of the old:

"It is better to have 100 functions operate on one data structure than 10
functions on 10 data structures." —Alan Perlis

------
danso
> _In order to accomplish that, we do need a way to describe processes. We
> need a way to "program." But switching the goal from building applications
> to analyzing and communicating information changes everything. Our current
> programming tools are awful thinking tools. Instead, they were designed to
> build complex systems. How much effort does it take to write a program to
> scan through your facebook friends and check to see if someone who usually
> isn't in your area currently is?...People aren't really tring to build the
> next Facebook, they're trying to use the information from it in a different
> way._

The example given here by the OP strikes me as a good example of how and why
programming is complicated, and what people generally _want_ their programs to
do is unlikely to be doable without knowing how to program.

Case in point: why can't a layperson just make a little app "to scan through
your facebook friends and check to see if someone who usually isn't in your
area currently is"? The ease, glib answer is: well, Facebook's developer API
requires several hoops to jump through, including OAuth of clients and so
forth. So that's why there's no drag-and-drop-plug-and-play module system for
such a feature.

The bigger answer is the answer to the question of why does Facebook's API
have to be so complicated? Well, besides business reasons...FB's API is a
public-facing abstraction over a system in which a billion people have agreed
to (semi-)authenticate themselves and communicate a variety of real-time
things about themselves. As annoying as it is to program your own little FB
apps...it's complicated because the system it interfaces with is
overwhelmingly and amazingly complicated.

I don't see much room for improvement in making programming easier in this
regard. It'd be like making Shakespeare more digestible to people who don't
want to learn to read (OK, ignoring oral storytelling, for this limited
analogy)

~~~
toby
Agree -- if Facebook had an "export my friend list to Excel" button, then
plenty of non-programmers could perform this task using existing tools.

I read the tutorial and I am sort of struggling to see what benefit this would
give someone who was already an Excel power-user.

~~~
ModernMech
Excel is a very powerful tool, but it reaches a utility plateau very quickly
when you start going outside its intended purpose of being a spreadsheet
application. You're correct that a power-user can do pretty much anything in
Excel, but when you start talking about actual database operations (like
Join), state, and UI, then you're at the point where the tool is working
against you.

~~~
JBiserkov
I'm not sure what you mean by state and UI, but Excel definitely has a join-
like functionality in the form of vlookup function.

[https://support.office.com/en-in/article/VLOOKUP-
function-0b...](https://support.office.com/en-in/article/VLOOKUP-
function-0bbc8083-26fe-4963-8ab8-93a18ad188a1)

~~~
mistermann
Now try doing a VLookup using more than one column.

Artificial limitations like this are one reason people rightfully hate
Microsoft.

~~~
tycho01
The so-so way: use MATCH in one column to get the row numbers, INDEX in one
column for each column you want to pull in to actually grab them using that
row number. Alternative: join the tables using Power Query so you could have
it refresh and give you the combined version even after adding more columns.

I mean, point taken, but in case you were wondering, then yeah. VBA also does
SQL operations on Excel tables, but that's, well, worse.

~~~
mistermann
> VBA also does SQL operations on Excel tables, but that's, well, worse.

Are you sure about that? Afaik it doesn't but I may be mistaken.

~~~
tycho01
Yeah, it could be done using the ADODB interface on data in the workbook
itself rather than from some actual DB. See this link for an example:
[http://stackoverflow.com/a/26678696/1502035](http://stackoverflow.com/a/26678696/1502035)
That being said, when I encountered someone doing this I was pretty surprised
as well.

~~~
mistermann
Pretty wild - it would be nice if MS would put a little effort into their cash
cows now and then so people wouldn't have to resort to such things though.

------
jordanlev
At a glance, it reminds me of what MS Access was (is?)... or could have been
if MS hadn't ignored it to death.

So many people (myself included) were/are incredibly empowered by that
program, and I still have a fond place in my heart for Access, as it was my
bridge from Excel macros to "real programming".

Hopefully Eve doesn't get DabbleDB'd... the world really needs a modern MS
Access!

~~~
kasrak
I work here, so disclaimer, etc, but we're working on a modern MS Access at
Airtable [1] -- it's very similar to DabbleDB.

It's early days both for Eve and for us, but it kinda feels like we're
approaching the same problem from different angles. Eve's more focused on the
programming experience while we're starting by focusing on the data.

[1] [http://airtable.com](http://airtable.com)

~~~
mistermann
This looks quite interesting. Do you have plans for a pricing model to support
building a public website on top of it? Also, will it only be (your) cloud
based?

~~~
kasrak
We're still figuring out pricing, but each base ("database") has a custom API
(the endpoints correspond to your specific schema) that you can use to build a
website: [http://airtable.com/api](http://airtable.com/api)

------
a-dub
So every time I've seen something like this (ETL tools, LabView, Scratch,
pd/max, etc) I've noticed a common problem. They're dead simple to create
simple things in, but often times simple things grow into complex things over
time and once things become complex things implemented in graphical
programming languages they become nightmarish to maintain. Subtle logic ends
up buried... Simple processes like a full search of a project or diffing
between two versions become impossible or clunky and you end up with the one
person who knows how to maintain X.

Is there anything here that addresses this problem?

~~~
ibdknox
Check out my note on visual programming. [1]

The short answer is we have lots of tools in mind that will help with this,
but programming this way just creates a very different kind of system. We've
built some complex things and they've remained fairly flat and we made sure
that it is both readily apparent what is contributing to your current query
and easy to navigate into it if you want to see more. For the most part these
problems boil down to navigation and debugging issues, both of which we have
really powerful ideas for. For example, we want our debugging story to be
what's called a "why? debugger" where you can click on any value in the system
and Eve will show all the data that went into calculating it and every query
it went through to get to here.

There's assuredly going to be lots more experimentation needed here, but we
have every intention of making this handle more complex things. We're
bootstrapping the compiler and eventually the editor, we've built clones of
websites, and we'll continue to push the edges of what we can do with it :)

[1]:
[https://github.com/witheve/Eve/blob/master/design/visualProg...](https://github.com/witheve/Eve/blob/master/design/visualProgramming.md)

~~~
gfodor
On this note it seems incredibly important to make sure the medium has
something analogous to refactoring in code: ways to tranform the system into a
better form in discrete, safe steps that do not change the behavior.

~~~
cmontella
Version control, refactoring, code reuse, etc. are big items on the roadmap
for the next release. We have some interesting ideas, including the
realization that refactoring in this sort of system can take the form of graph
rewrites.

Here's a post on our dev diary about version control:
[http://incidentalcomplexity.com/2015/04/22/version-
control/](http://incidentalcomplexity.com/2015/04/22/version-control/)

------
BjoernKW
The way I understand it Eve is aiming to be both a better Excel and a better
Lotus Notes. I think its creators are still on to something.

These tools are often ridiculed and their use by non-programmers for creating
business tools is often frowned upon but they allow business users to quickly
create flexible, makeshift solutions to their problems. Not every business
problem needs to be solved by a complex, cumbersome JEE application and an
expensive application server.

While Lotus Notes apps certainly look awful and feel clunky most of the times
there is a certain elegance to being able to quickly whip up a solution to a
business problem or an urgent information need without having to go through a
lengthy collection of requirements and approval process first. The same
applies to Excel spreadsheets: They're a great tool for iterating quickly and
getting a certain class of jobs done. Something like a REPL for non-
programmers.

~~~
IanCal
> These tools are often ridiculed and their use by non-programmers for
> creating business tools is often frowned upon but they allow business users
> to quickly create flexible, makeshift solutions to their problems.

They do, which is both great and terrible. They're powerful and easy to get
started with, but therein lies the danger.

When used to quickly whip something up they're great, but when those things
grow or end up being relied upon they're no better than the hack that the CEOs
kids friend who is 'good with computers' produces.

So, since they're both useful and dangerous, are there things we can do?

Perhaps a spreadsheet that allows some form of testing? Are there simple tests
we could start to encourage people to use? When I've used spreadsheets for
some financial things, I know that if I increase one cell, I expect another to
increase (for example). I know certain combinations of inputs that should
result in certain outputs.

Also, perhaps a clear path from spreadsheet -> application? Often intermediate
values are displayed somewhere, so could a spreadsheet app lead someone to
naming them all (typically they'll have a 'variable name' just to the left of
them).

edit - I should really have read the article first, but I think a focus on
making things testable is important.

~~~
jamii
That's definitely something we spend a lot of time thinking about. We have to
be able to support easy, exploratory programming but also be able to nail
stuff down if it ends up being used a lot.

We have a bunch of ideas queued up. One of the simplest is generating fake
data as you write code so that you have a better chance of noticing edge
cases. We are also planning to proactively hint about integrity constraints
(types, unique/foreign keys etc) eg if a column only contains integers, show a
button that fixes the type to integer. There is an optional typing system in
the wings too.

There is also lots of similar research aimed at spreadsheets (eg
[http://eusesconsortium.org/wysiwyt.php](http://eusesconsortium.org/wysiwyt.php))
which we can borrow from.

------
fortytw2
Interesting ideas, very different, but still reminds me a lot of Light Table
(probably because they have the same author :p)

Seems to be built on a rather interesting Rust + TypeScript stack? Can't say
I've seen that one before - anyone have experience with such a stack?

~~~
mej10
The stack choice is especially interesting since I thought they were big fans
of Clojure.

I would like to hear their rationale for Rust/TypeScript over
Clojure/ClojureScript (or Clojure/Javascript).

EDIT: typo

~~~
jamii
There was some discussion in
[http://incidentalcomplexity.com/2015/02/24/january--
february...](http://incidentalcomplexity.com/2015/02/24/january--february/)

> While running in the browser is a requirement for Eve, it's always been
> clear that using javascript directly was not a long-term option. So many of
> our implementation problems come down to lack of control over data layout.
> For Eve we need to implement:

> New types (like intervals) - but there is a space overhead of 24 extra bytes
> per object Polymorphic comparisons - but dispatching on typeof is slow
> Cache-friendly indexes - but it's hard to store multiple js objects
> sequentially in memory Radix tries - but converting strings to bytes is slow

> We also want to be able to distribute native code for mobile devices and use
> real threads on servers. Lastly, there is some benefit to using reference-
> counting for the indexes so that we can avoid copying nodes when we know we
> have sole access.

> We ruled out C++ and D on aesthetic grounds - we have a preference for
> small, simple languages that we can understand completely. Rust wins points
> for safety and abstraction but the toolchain is not nearly as mature and
> there are issues that currently prevent compiling with Emscripten. C gives
> us less support in the language but is much more future-proof at the moment.

I also wrote about our experiences with Rust later at [http://scattered-
thoughts.net/blog/2015/06/04/three-months-o...](http://scattered-
thoughts.net/blog/2015/06/04/three-months-of-rust/)

~~~
PopeOfNope
I'm curious, why not LuaJIT? It's small and fast and when you need it to be
faster, it has excellent C FFI and the ability to add inline assembly[0].

[0]:
[https://gist.github.com/lukego/d15f3a65bd316ea2c2b6](https://gist.github.com/lukego/d15f3a65bd316ea2c2b6)

~~~
jamii
We needed control over memory layout and some path to running in the browser.
I considered writing the data-structures in C and the rest in Lua but it would
require more manual memory management than Rust and there is no clear path to
compiling mixed Lua/C projects into Javascript.

~~~
PopeOfNope
That's a good reason. :)

------
viraptor
> Imagine what we could do just with a version of office where every bit of
> information was sourced live from a database, where instead of Power Point
> presentations of status you could throw together a dashboard and send it to
> everyone in the organization.

The thing is... you can. Not a presentation / PP, but if you want to create a
self-updating dashboard, you can do it in Excel. It's not going to be super
easy, but you can do pretty much all of it by clicking.

Here's excel with a sheet that comes from sql database. It's trivial to add
another sheet with just graphs on it. [https://support.office.com/en-
ie/article/Connect-to-a-SQL-Se...](https://support.office.com/en-
ie/article/Connect-to-a-SQL-Server-database-Power-
Query-e5004318-0f2e-46a3-8b15-1559aa3c04db?ui=en-US&rs=en-IE&ad=IE)

But if you want to do a "dashboard proper", you can use the Power BI tool:
[https://support.powerbi.com/knowledgebase/articles/471664](https://support.powerbi.com/knowledgebase/articles/471664)
(which looks super amazing by the way for an office product, is free, and I
want to have a reason to actually use it...)

It's strange that they didn't even mention those possibilities in the post. I
see how they could try to improve a lot in those approaches however.

~~~
tycho01
In fact, Power Views stored on SharePoint _can_ be embedded into PowerPoint
from my understanding. ... which unfortunately complicates things, but yeah.

------
rafaelferreira
The new value proposition is reminiscent of DabbleDB, which was a
groundbreaking product that didn't seem to get enough traction to sustain a
business. Is this comparison apt? Any ideas on why Eve has a better chance of
succeeding?

~~~
scottjad
The comparison is very apt.

Dabble is the main reason I don't have much hope for Eve.

Dabble was amazing, it did everything in the Eve Tutorial much better than Eve
does, it didn't require installing anything on your computer, it looked
beautiful, it was very easy to use, it had great collaboration, and it had a
TON more features than Eve, and it had excellent customer support. Dabble is
one of my all-time favorite apps and I think it's one of the best webapps
ever. And it didn't succeed.

I guess it's hard to know what might have happened with Dabble had they not
created a separate analytics tool that was attractive to Twitter. Would
someone else have bought Dabble and continued to support it? What if it had
been built on a more mainstream architecture? I always thought Dabble would
have been sustainable as a small business. Something about recent history
(i.e. LightTable) tells me these guys aren't likely to toil away supporting
this for the next 10-20 years to earn a modest income.

I can think of at least three limitations Dabble had that some future version
of Eve might not have:

1) There were only so many primitive operations (conversions, calculations,
filters, etc) and so there were some "programs" that you couldn't create.

2) For creating a UI, you basically had forms and reports. They had a great
implementation of both of those, but they were the only tools you had.

3) You couldn't see the code. Just as Excel has the code hidden in a cell
somewhere, in Dabble if you had a derived field (some calculation) you had to
click on the field to see how it was calculated. It appears Eve has or will
have some way of graphing these calculations so a program can be "read"
without clicking on fields to see their formulas.

------
nikki93
A few other things to check out in this realm:

[http://unisonweb.org/](http://unisonweb.org/)

[http://www.selflanguage.org/](http://www.selflanguage.org/) (esp. the papers
on the UI)

[http://www.subtext-lang.org/](http://www.subtext-lang.org/)

[http://www.cs.virginia.edu/~evans/cs655/readings/smalltalk.h...](http://www.cs.virginia.edu/~evans/cs655/readings/smalltalk.html)

I like to try to experiment with this stuff as game development tools, because
games are highly realtime / graphical / interactive and that's hard. It's easy
to write an A -> B transform (like a compiler is a lang1 -> Either error lang2
transform for example) functionally, because ultimately that is a function.
Doing interactive compute this way is hard, and that's where FRP, FRelP
(functional relational programming) and a bunch of stuff could be used.

I was trying some interactive game dev stuff with this:
[http://ludumdare.com/compo/2014/08/27/reminisce-post-
mortem/](http://ludumdare.com/compo/2014/08/27/reminisce-post-mortem/) (allows
live coding and live edit) but some issues popped up as highlighted in the
paper about it. I think a prototype-based approach like Self could be a good
way to go. Also doing it in lispy languages to abstract the language upward
while abstracting the problem downward.

The Out of the Tar Pit paper is really a good one.

Doing things this way allows more immediate connection to the creative spirit,
as on the other side of the more 'logic'/'rational'-based one, which is sort
of like static typechecking in human thought -- it prevents error, but to move
forward you some times have to make leaps of faith/intuition. Like between two
paradigms (check out Kuhn on scientific revolutions, or Science, Order and
Creativity by Bohm). Need to be in and about the artwork. Sorry, been reading
a bunch of Nietzsche / Psycho Cybernetics / Prometheus Rising type stuff and
this is on my mind
([http://www.paulgraham.com/top.html](http://www.paulgraham.com/top.html))
right now haha.

~~~
jamii
Since you mention game development - the architectures behind Love
([https://www.youtube.com/watch?v=DPIA2g8T6Hw](https://www.youtube.com/watch?v=DPIA2g8T6Hw))
and Bitsquid ([http://bitsquid.blogspot.com/2010/04/our-tool-
architecture.h...](http://bitsquid.blogspot.com/2010/04/our-tool-
architecture.html)) were both big influences, demonstrating that it's possible
to build composable tools while still having the accessibility of rich GUI
apps.

~~~
nikki93
Yeah games are a fun example to work with for such tools. Almost as if game
development tools are an 'instance' of the prototype of 'development tools,'
and rather than simply working on the abstract class it's nice to work on a
prototype then expand. :)

Games also have an aesthetically-minded end point, rather than a solution-
minded one, which keeps the focus on aesthetics/human values in focus.

------
cpr
So it looks like they've come a rather long way around to building the world's
best graphical query builder, with plans for much more beyond?

~~~
eterm
OT: I hope that is the case. I've been responsible for building query-like
tools for end users, and all the current stuff out there completely sucks.

For example, no non-programmer I've ever talked to can correctly explain the
difference between:

A and B or C

A and C or B

And to be fair, it's only because of arbitrary precedence rule choices that
those are different at all.

I've personally found that dealing with groups and instead of having "AND, OR"
you have "ALL, ANY" and always group rules (even if they're groups of one
rule).

But even when you have that, you then have to deal with nesting rules, and
nests of nests.

The actual implementation of the backend of such systems is easy, the
composite pattern / delegates pretty much deals with the implementation.

But the front-end side? They tend to then be forgotten and universally suck,
to the point that either it gets handed off to a developer or query-tool
expert to use, or some horrific mistake such as accidentally mail-shotting
everyone[1] which causes them to never try to have automatic query rules
again.

Graphical query building for the end-user is a really difficult area which
hasn't seen enough research.

[1] I want to mail Visited Yesterday And are either Men Or Under 30. Instead
of "Visit > Yesterday AND (Men OR Under 30). They forget the brackets. Whoops,
that's half their clients hit.

------
tzakrajs
I still have no idea what this is after reading the blog.

~~~
z92
It's a MS Access like desktop database application. That's what I understood.

~~~
adinb
That's how I understood it as well; maybe I'm missing something?

I'd love to see a web-native supported version of Access or File maker that
was fully open source and had modern programming languages fully baked in.

------
sanxiyn
I always thought BOOM was a very cool system, so it's nice to see something
influenced by it.

I find it interesting that BOOM emphasized scalability, but Eve seems
completely uninterested in that aspect.

~~~
nekopa
Maybe that's because they are trying to target 'non-programmers', so scale
probably is not an issue for them. But that may hurt them if they want
'serious' programmers to take note.

For me, I want to try it out because there are a million little things I would
like to do just for myself, not at web scale...

------
shubhamjain
Wow. This is something that I had pondering over the past. A major frustration
I notices with people using excel is Data-Entry coupled with horizontal
scrolling. I was sketching a app with cells that are like MongoDB like
collections and computations that can defined elsewhere.

Although, people have called making a generalised CRUD software, nearly
impossible task, but I bet that, in that domain lies a room for an innovative
conceptualisation of the problem. Maybe, in the next decade, we can see
software with which people don't have to look for freelancers just to build a
Data-Entry App. Good luck, Chris!

~~~
dalacv
take a look at Oracle APEX and KnackHQ.com

------
hyperliner
It is good that we keep trying at this problem. Does it feel that as an
industry keep trying to solve this problem and never "quite" get it right? I
have read about the old "CASE" tools or old VB approaches, for instance. Even
Microsoft Access now can generate applications on Azure backed by SQL Azure
(SQL Server for the cloud), then there was some Intuit tool (can't remember
the name). One can argue Excel itself was quite good at some of these apps.
More recently seems like Dabble or Popfly were a thing at least for a few
months.

Every time something like this happens, "real developers" feel threatened,
while business users love them for their side projects when the "real
developers" are too busy to care.

Maybe these types of tools are always destined to come up again (since we
reinvent the platforms all the time), and then a few users use them, while
real programmers for the most part simply yawn once more.

Are we ever going to push programming to a level of maturity where we can use
building blocks and be real productive, yet have the flexibility to create
real, sophisticated applications?

Seems we never quite get there.

But it is positive to see that new generations of developers don't stop
trying.

------
Animats
Bad name choice. There are already too many better known things called "Eve".

~~~
corobo
Honestly I thought from the thumbnail this was the very first iteration of Eve
Online - Main thought was "Holy damn they put a nice GUI on that spreadsheet"

------
DTE
Eve looks incredible. I love seeing the the UI stuff that these guys put out
as its a non-trivial problem to wrap a complex programming model with an
interface (graphical) that can expose both powerful as well as generic
functionality. The crew at Eve/LightTable are taking on a huge project and are
clearly extremely talented. We would all do well to follow this project as it
matures. Keep up the great work.

------
MrDosu
I think the major problem with this approach is trying to solve the general
Problem.

These graphical abstractions can be excellent when tailored to a domain. We
are shipping a product right now that abstracts the database away through a
little graphical graph editor like this one to transform it into the domain
language of the people (non programmers) that are consuming the data.

It is quite excellent.

~~~
nekopa
Can you explain more, or even share your project? It sounds quite interesting.

~~~
MrDosu
Unfortunately I cannot share code.

It is actually quite simple. There is a graphical designer that connects to a
data warehouse. There someone defines a graph like structure with nodes that
contain a collection of data rows and relations to other nodes of data rows.
This results in a library that you can interop with in existing software tools
of the customer to query that graph model naturally (Stuff like
Location('airport')=>Car('sedane')=>RentalHistory). It's basically a glorified
ORM mapper with a graphical programming language for the codegen of the
objects to produce a kind of data DSL.

~~~
dman
What is the domain in question? Have you run into issues where the power users
who are non programmers want to do more programming like tasks over time to
exert more control?

~~~
MrDosu
The domain is (non technical) government data analysts.

Yes we ran into this a lot with people wanting more control. There are several
hooks and extension points in the software. Basically every graphical element
has the equivalent of being replaced with an actual code file that you can
substitute at runtime. This gets never used by the customer, usually we just
provide extension libraries that abstract the concepts of whatever they want
to do.

------
jason_slack
This sort of reminds me of my old FileMaker days in terms of the way you
layout the UI, populate it, etc.

I'll definitely keep an eye on this, I feel it could be very useful.

------
chilicuil
The quick instructions didn't look really quick to me, so I created a vagrant
setup for those who don't want to install TypeScript, Rust Nightly, and
multirust in its local machines.

$ git clone --depth=1 [https://github.com/chilicuil/eve-
vagrant](https://github.com/chilicuil/eve-vagrant) && cd eve-vagrant

$ vagrant up #this may take a while

$ xdg-open [http://localhost:8080/editor](http://localhost:8080/editor)

The above uses a plain precise 32 box and install eve and its dependencies in
the provisioning phase, I've also created a modified box (583MB) with eve
dependencies hard-coded, which could serve better those who don't have
precise32.box anyway.

$ git clone --depth=1 [https://github.com/chilicuil/eve-
vagrant](https://github.com/chilicuil/eve-vagrant) && cd eve-vagrant/partial

$ vagrant up #this may take a while but not as much as the above

$ xdg-open [http://localhost:8080/editor](http://localhost:8080/editor) ```

------
slantedview
Really excited about this work and interested to see where it goes. Reading
this:

"even many of them expressed wanting to automate processes or bring a bunch of
different types of information together"

...makes me wonder: are we just talking about a better ITTT type of thing?

------
27182818284
Light Table is dead or alive at this point? I hear so little about it I can't
help but feel it is on death's door or dead. I'm sad about that. It seemed
like it could have been something really cool.

~~~
divs1210
Not sure what you're talking about. I use it almost every day for clojure/js
and sometimes python when I just want a quick script. (PyCharm for actual
dev).

~~~
27182818284
I have it installed on my machine too. I just hear nothing about its future
and it seems like folks are focused elsewhere too. E.g., this topic about Eve.
Especially for something YC backed. I guess I was just expecting to hear more
and such.

~~~
ZenoArrow
IIRC the next release (version 0.8 I believe) is focused on porting to use
Electron for its GUI. It doesn't appear to be dead, though I'm sure the devs
wouldn't mind a little help (a willingness to try ClojureScript is probably a
big plus if you were interested). ClojureScript is a Lisp so it should be
fairly easy to pick up the basics.

------
srtjstjsj
What happened to Light Table? Did it evolve into Eve? Is Light Table
abandoned?

~~~
moron4hire
He had a blog post about this, how early design decision to make absolutely
every feature in the editor a plugin over-complicated the design to the point
that he was the only one who could maintain it, and maintenance was all the
more he could do. So yes, LightTable itself is done. He also said he planned
on returning to addressing the goals of LightTable in the future.

------
zubairq
Great stuff. When will there be a hosted version I can try out?

------
tedsuo
I kind of did an eye roll at the breathless language in the announcement. I'm
trying to unpack that reaction, because I actually really enjoy the first-
principles approach that they have taken with their work.

I think, perhaps, it's because there's a fair amount of praxis already out
there in the enterprise and small business sectors about this, and I didn't
really see reference to any of that, Lotus Notes notwithstanding. I know it's
nitpicky, but it was a strong reaction so I thought I would share it. I'll try
to unpack it more:

Basically, creating data processing tools for humans is such a fundamental
application of computer science that we even have a name for it: Information
Technology. And, ever since the Mother of All Demos we have been trying to
make a kind of "omni-tool" for data processing, and pretty much falling on our
faces.

This is perhaps because a "general purpose tool" usually turns out to be a
particular kind of "special purpose tool". The question is whether a large
enough segment benefits from general purpose tooling, which entails taking on
the overhead of learning how to use this "tool that makes tools" in order to
accomplish their many tasks. In other words, there's a layer of indirection.
Or, are most people's problems disjoint and specific, so that they benefit
more from using a few special purpose tools that can then be loosely coupled
together.

For example, let's say for my job I have to manage the generation of reports,
etc, and post them on a company website that I maintain. I can use a document
editor to edit documents, a communication service to send links to the
documents, and a web-based CMS tool to post the final reports to the website.
It's not clear that I would be better served, or even could be served (due to
the network effect), by an all in one tool-builder tool. Three special purpose
tools, which can guide you effectively in each task, might be easier to deal
with than one general-purpose tool, all user grousing aside.

This particular type of omni-tool could be described as a"Distributed
Filemaker." Filemaker-like tools are definitely popular, but tend not to
unseat other special purpose tooling. And they have a problem shared by all
powerful data modeling tools: they provide you quite a bit of rope to hang
yourself with. If you want to really improve in this space, I suggest you
focus on providing a data modeling and coherency paradigm that is appealing to
non-technical users, yet successful for managing long term data that changes
meaning over time. That would be profound, as poor data modeling is pretty
much how all of these projects eventually crash on the rocks. Your users will
not ask you for such a thing though, as they don't understand it.

In spite of the eye roll, I wish you luck!

------
mej10
Congratulations on getting this out there! Looks like the team has made a lot
of progress. Looking forward to trying it out.

------
mach1rcode
If their primary focus is business/knowledge workers, why wasn't their release
targetted to Windows?

~~~
jamii
It is kind of a pain to build on Windows right now, but it is a supported
platform and we will eventually have pre-built binaries.

~~~
mach1rcode
Thanks, have been looking forward to testing this as I am essentially your
target demographic.

------
rajacombinator
Just from looking at the pics on the blog post, it looks much less simple or
intuitive than writing a few lines of python. There's a lot of money to be
made selling such things to enterprises that don't know better though.

------
ultix
So let's get this right...they couldn't write a stable IDE (reaching version
1.0) without re-writing it several times, inventing crazy tools to get around
their platform limits (Lighttable runs on NodeJS?!?). And now they expect us
to think they can revolutionize computing not just an IDE?

Sorry, but this project is way to ambitious and run by people who have way to
weak of a track history to inspire confidence. Go back and finish what you
started on, and what you took money for, instead of taking more funding for an
even bigger project.

Reminds me of half the Kickstarter games these days: "whelp that didn't work,
good thing we don't have to give you your money back!".

------
Sukotto
Kudos for putting a link to basic info at the top of your post. I wish
everyone did that (just make it part of your blog template).

------
dominotw
Is anyone using LightTable on a daily basis?

I sponsored the kickstarter but never really followed up on what happened to
it.

~~~
gohrt
Looks like the authoer coded himself into a corner and gave up, and is trying
this instead. Not inspiring faith in the prospects for Eve.

~~~
CmonDev
Yeah, but this time he borrowed money from people who cannot be duped.

------
bencollier49
Confusion reigns. They should call it Evie.

------
CmonDev
I wonder if he will finish this one...

------
moea
"topmind" strikes again!

------
aerovistae
Bugs me when people choose a name that's already being used for something much
better known.

~~~
dcre
You mean the game? Not sure there's much potential for confusion.

~~~
spdionis
The game is famous enough to create real confusion. Especially in geek social
circles I guess a very high percentage of people immediately think about the
game when seeing "Eve".

~~~
pki
To be fair, the game is also basically groupware and spreadsheets and
databases ;)

[especially for the corps that take nullsec seriously]

~~~
spdionis
I haven't thought about it but, hey, you're right!

------
w_t_payne
I'll be happy when it gets vi keybindings

------
_pmf_
> what it seems like we need is something more akin to the original vision of
> Lotus Notes - an environment full of information where communicating that
> information to people or even other systems is a fundamental primitive.

Oh boy, here we go again. A more direct admission of not knowing what to build
is hardly imaginable.

