ibdknox

Nope, though we all play in a similar space and I know several of the people in Flex - they're fantastic folks doing really interesting work. :)

I'll be excited to learn more about your latest work :)

I probably did a poor job explaining, but that's what the example is: an app that a food truck owner could use to run their food truck. :)

> There must be a better range of use cases.

There are lots of businesses I'm sure we could build, but that's not really our goal. This one happens to be straightforward and real, so it seemed decent. Do you have any suggestions that you think would make for a better demonstration?

[Eve member]

Out of curiosity, what would you classify as a practical application? We're looking for some interesting examples to build to help show Eve to folks.

EDIT:

For instance, one of the examples we're throwing together now is an app that a food truck owner could use to put up their menu, manage a queue of orders (in person and online), alert people when their order is ready, accept payments, and post to social media. We picked this because it's an app trucks could actually use and it has lots of "real" functionality in it - from stripe integration to social media posting. Also, who doesn't love food trucks? :)

It is, but it's a multi-step process. :) Checkout the three milestones at the bottom of the post: http://programming.witheve.com/#justataste

This milestone is very much about making a programming environment, so you're right, that's still code. Though to address this strawman, compare that to what you would write in Java or even Python. Some of the best comments we've gotten is when we've shown people eve code and told them to ignore the symbols, just read the words. Their eyes really open up and they tell us pretty exactly what the block is doing. No, it's not all the way there, but that's a big step forward.

In any case, check out our followup on what Eve is and isnt [1] - we're under no delusion that this is the end user story... yet :)

[1]: http://programming.witheve.com/deepdives/whateveis.html

Trying to do literate programming in traditional languages is pretty crappy [1]. Some heroic effort ended up having to go into this release as well so things aren't as commented as we wanted, but that will improve. There are a few files that are pretty good though [2].

Our Eve source on the other hand is wonderfully literate and it's been a really great experience. Here's the code that makes the inspector work [3].

[1]:http://programming.witheve.com/deepdives/literate.html

[2]: https://github.com/witheve/Eve/blob/master/src/runtime/join....

[3]: http://play.witheve.com/#/examples/editor.eve

There's still code here, the text is just for people, so I wonder if this is maybe a misunderstanding.

The language presented is a variant of datalog and is as formal as any other language. If you're curious in the semantics, they boil down to Dedalus [1].

As a simple example of that, here's a clock: http://play.witheve.com/#/examples/clock.eve

[1]: https://www2.eecs.berkeley.edu/Pubs/TechRpts/2009/EECS-2009-...

Should be fixed, try hard refreshing.

I at least fixed the main webpage's issue with not-quite phone sized screens.

Check out our followup on that : http://programming.witheve.com/deepdives/whateveis.html

1) Eve is amazing at graph algorithms, not so much at writing quicksort. At the same time, you don't need to write quicksort in Eve - it has all of the things you'd get from something like a SQL database. In general, anything requiring strict sequential order will be just ok right now, but it turns out actually very few things do.

2) sure and we have written some of it in Eve, check some of my other comments for links :)

That's fair. We don't talk about it in here because there was already way too much to discuss, but we've done a few non-trivial things in Eve. All of the inspector interactions are actually written in Eve [1], as is the program analyzer that provides the intelligence to make it work [2]. An important thing to keep in mind as well is that Eve does a lot with very little. 10kLoC of Eve would implement most systems twice over. So the programs will always be pretty short.

The intent is to handle anything you could imagine writing in python. As this is 0.2.0 of a language pretty unlike anything currently mainstream, we're nowhere near there, but with engineering there's no reason we can't be. The IDE is only one portion of the story here, the languge is another one. It's a variant of Datalog that has far reaching implications on how we can work in teams (global correctness), how software evolves (complete compositionality), and how we think about larger scale systems (orderless and distributed). The latter will be the highlight of our second milestone where we'll do another big release like this one, but for the rest we'll be doing deep dives over the next couple weeks about how we believe this language scales much better to the realities of software today.

More is coming. :)

[1]: https://github.com/witheve/Eve/blob/master/examples/editor.e... [2]: https://github.com/witheve/Eve/blob/master/examples/analyzer...

Hi All!

Many of the folks here have been following us for a long time and we're really excited to finally pull everything together to show you all where our research has taken us. Eve is still very early [1], but it shows a lot of promise and I think this community especially will be interested in the ideas we've put together. As many of you were also big Light Table supporters, we wanted to talk about Eve's relationship to it as well [2].

We know that traditionally literate programming has gotten a bad rap and so we laid out our reasoning for it here. [3]

Beyond that, we expect there will be a lot of questions, so we'll be around all day to try and answer them. We'll also been doing a bunch of deep dives over the next several weeks talking about the research that went into what you're seeing here, how we arrived at these designs, and what the implications are. There was just way too much to content to try and squeeze it all into this page.

Also, a neat fact that HN might be interested in:

Eve's language runtime includes a parser, a compiler, an incremental fixpointer, database indexes, and a full relational query engine with joins, negation, ordered choices, and aggregates. You might expect such a thing would amount to 10s or maybe 100s of thousands of lines of code, but our entire runtime is currently ~6500 lines of code. That's about 10% the size of React's source folder. :)

[1]: http://programming.witheve.com/deepdives/whateveis.html

[2]: http://programming.witheve.com/deepdives/lighttable.html

[3]: http://programming.witheve.com/deepdives/literate.html

Out of curiosity, would you say the same thing about Clojure? It's also a home-grown language with its own non-standard terminology that is non-trivial to learn. Any fundamentally interesting change in programming will fit that description. Rust, Go, even Typescript, add a bevy of new syntax constructs and a whole set of terminology that isn't shared with other languages (borrowing, type definition files, goroutines). Every library brings with it new semantics and new terminology to deal with. It's not like datascript is inherently obvious to folks.

The important bit from that line of thinking is that there's a cost to adopting it and the benefits have to outweigh that cost. We haven't talked much about what those benefits are, so I get where you're coming from - it may indeed look like we've "lost the plot." :) Most of our content is geared toward people who are already interested in what we're doing and want to follow along with the work. It's very much not a pitch at the moment, that will be coming in a couple of months. You can pick up on some of it from what we have shown though:

- Eve programs are naturally tiny (no tricks/golfing/epic one liners). The CLJS libs you mentioned all have TodoMVC implementations that are ~5x as large as Eve's (just 63 lines!).

- There's no incidental ordering in the language, which means you're free to organize your program however you want. As a result, it enables truly literate programming.

- Another result of a lack of ordering is that programs grow very organically through composition. Want to react to an event on a thing someone else created? Write a block that matches for it. Want to add some fake data into the system? No changes needed, add a block that adds some data. Want to visualize where all the active users are in your app? Write a block anywhere.

- Eve programs aren't talking to a database, they are the database. That means no plumbing, no impedance mismatch, and no extra infrastructure is needed. A practical example of this from one of my tweets[1]: I can take our todomvc add three @global tokens (changed from "all") and we now share todo lists. No server setup, no client->server transport, etc.

- Eve's semantics were built for concurrency, asynchrony, and distribution. There are no promises, or thread synchronizations, or borrows.

- Correctness can be defined globally through integrity constraints, allowing people to safely contribute to an application without worrying about checking every possible invariant locally. No more null checks and Joey can't check something in late at night that allows people to have a negative salary.

- Everything is data. The file system, http requests, the DOM... That means everything can be queried and everything can be reacted to. Want to be alerted when the machine you're on is running low on memory? Write a match against the machine's memory and commit an email when it dips below a certain threshold. Want to know how many open http requests there are? It's just a query away. With no indexing, no passing things around, no real effort at all, you can ask any question about your system you want.

- Since everything is data, we can provide amazing tools. A very simple example here: [2].

Excitingly, the list continues on, we're just focusing on making Eve a lot more real before we tell people about it. It's up to us to prove and communicate what Eve brings to the table and we're taking that very seriously. My blog post about Light Table was never meant to be a big deal - I did it on a whim. Eve, on the other hand, is deliberate, well researched, and well grounded. As you suggest, it will take a lot to convince folks that there's a net gain to the switch and so we're collecting lots of evidence. Amusingly enough, in some ways we're actually returning to the original "plot" - one of the demos I want to do in October is a recreation of the LT demo. We finally have a language with the semantics necessary to fulfill that vision. :)

[1]: https://twitter.com/ibdknox/status/755450540104884224 [2]: https://twitter.com/ibdknox/status/760963855296016384

Seems similar in spirit :) They do a version of one the original demos: https://youtu.be/gtXpOD6jFls?t=49s

The expectations for research and the expectations for engineering are different, and I suspect that's where a lot of this comes from. We've kept our burn insanely low (we still have a full startup's worth of runway left), because we knew we didn't have a handle on exactly what the problems were or exactly how to solve them. We're not naive enough to think we can waltz in and do something very smart people have been trying to do for 50 years - we needed to take our time and explore the space. We've tried to communicate that in several ways: always talking about experiments, posting bibliographies, doing a few talks on the crazy ideas we tried, etc. All in all, I'm really proud of what we managed to do in two years - it's easily several PhDs worth of work (our full bibliography is over 300 papers!).

We've had a rationale up for a while [1] and our first post on incidental complexity also went over a lot of that [2]. But given the above it's certainly not as explicit as you're wanting, because until very recently we hadn't figured out the exact what or how. The plan for the fall release is to present a real system for people to use as well as a ton of content to lay all of that out in detail. We'll be drawing lines between all the various things we've done and all the papers we've read to the real working system - tradeoffs and all. We're actually really excited about it - it's been tough figuring out how all this is meant to fit together and we have the opportunity to present things in a very exploratory way, where people can dig as deep as they want (there'll be weeks worth of stuff). Once we pull a first draft of that together, I'd love to send it to you to get your thoughts.

[1]: https://github.com/witheve/eve-experiments/blob/master/desig...

[2]: http://incidentalcomplexity.com/2014/10/16/retrospective/

Sorry our research seems to have offended you. :(

All our experiments have been moved to here: https://github.com/witheve/eve-experiments, which has the complete history of all the versions we've built.

Our work is all open source, we've published our bibliography, and we've talked about all the prototypes and what we've learned from them here [1]. The only time we asked for money was the Kickstarter, which was only done because HN community specifically asked us to. Is there something specific you're particularly upset about?

[1]: http://incidentalcomplexity.com/

For a very brief period of time it was actually a standalone product that was being developed when I was at MSFT (2010ish), but eventually they just rolled it into VS.

Lightswitch was an amazing example of poor positioning. If you looked at the marketing material for it, it was positioned as a tool to "build three tier web applications" followed by a bunch of words that I didn't really understand.

It's really sad, because the tech there was really impressive.

Despite much of the hate VB has gotten over the years, it served an insanely important purpose in the rise of internal business software. When I was at MSFT, me and the PM who owned the compilers for VB.NET and C# did a usergroup tour through Florida and I was amazed at how much of their world still runs on VB6 applications. Something like 1/3 of insurance software still does. It was one of the biggest reasons that Microsoft had to keep extending support for XP.

The transition from VB6 to VB.NET was a really sad one as it lost a lot of people - .net is a lot more difficult than 6 was. The result is that an entire group of people simply stopped making software and now we have businesses running on applications that are more than 20 years old that some random person in the company threw together over a week. There's a huge gulf between building a VB6 app and throwing together a web app today and despite much of the progress that has been made, we've taken some big steps back in terms of accessibility.

The difference between VB.NET and C# is pretty superficial, but I sincerely hope that someday people can experience the magic that something like VB6 offered. A lot of people got their start in programming thanks to it (myself included) and it's sad that it fell by the wayside to make way for "real programming."

FWIW, You can get transaction-time and the associated wall clock time in datomic's query language as well, though admittedly I can imagine cleaner ways of doing it :)

http://stackoverflow.com/questions/11025434/in-datomic-how-d...

That is indeed the premise of Datomic, so I'm not sure how that would be a differentiator in this case. Beyond that, it's hard to make any statements on the difference between the query languages without more examples.

You have symmetric read and write rates? That's pretty odd. Also if you are writing at that rate, presumably those writes aren't persisted?

EDIT: That's also a rate of 1.6us per query. I've never heard of a JSON/REST stack that could take in and return results in that period of time. Are you doing something special to accomplish that?

Depending on whose count you believe, there are 500-800M Excel users in the world. So it's more than order of magnitude (if not two) smaller than Excel.

It's all HTML at the moment.

Huh, thanks for the link, I hadn't seen this talk of his. We take a ton of inspiration from the work done the 70's and 80's before we decided exactly what "computation" meant. There were so many great ideas that elevated what we could do with computers, it's sad that 40 years later we're sitting here trying to rediscover them.

whoops, yes I did. Fixed in the gist. Thanks!

haha that does more or less represent the past couple years of my life :)

Btw, if you found those two lines interesting, I did an essay/talk about coming to that conclusion: http://www.chris-granger.com/2014/03/27/toward-a-better-prog...

Amusingly enough, I actually started thinking a bit about this just the other night after being told about a talk given at Dropbox about accessibility. To be up front, we know very little about it and the other night was the first time I'd ever tried to use a screen reader, so it's something we aren't likely to be good at right of the gate, but it is something we've been setting ourselves up for completely by accident.

Many of the previous versions of Eve would be pretty completely inaccessible, so your dismissal would definitely be warranted. The version we've decided to run with though basically has three parts: a document editor, embedded spreadsheet cells, and a fancy plain english search. All three of which have a history of accessible solutions, so that makes me much more optimistic that we can provide something nice here. Along the way, another thing we've been very cognizant about is making sure no matter what form of input you prefer, Eve should be efficient and useful to you whether you're using a keyboard, a mouse, or touch. Many of the interaction issues we'd need to solve to better work with screen readers popup when trying to support complete keyboardability, but I have no delusion that there will be plenty more to solve there. Another interesting aspect of this version of Eve is it's really easy to imagine a voice interface to since virtually everything is done using plain english queries - it'd be kind of like having Jarvis in your google docs.

Admittedly, we don't know what we're doing when it comes to accessibility, but it is something we've been thinking about indirectly and it's something I think we can at least do more naturally than the code editors of the world.

Thanks for raising the issue and it's something I'd like to have a more concrete answer for in the future.

I thought this was a great article when he posted it and it's always really exciting to see people engage with us about the research we've done. He links to it at the bottom, but here's a link to my followup [1].

We've learned a ton over the past couple of years and we've finally settled on a path forward. That means we're starting to move out of research mode and starting to execute on all of this knowledge gathering. To that end, we're going to be doing a public alpha release in the next few weeks for people to play with. :) It ought to be interesting to the folks here to see how crazily different our work could be - the latest version of Eve is better likened to Medium's content editor or Dropbox's paper than it is to Visual Studio. It's been a long road (with around 30 versions of Eve at this point), but there are some really exciting times ahead.

Happy to answer any questions! Though I imagine there'll be plenty of discussion when we do the release :)

[1]: https://gist.github.com/ibdknox/2b185fcb8e5d1de68796