Bayle Shanks's website: notes-computer-programming-programmingLanguageDesign-prosAndCons-eve

biot 4 days ago

Was there a problem inherent to building large applications that you found intractible, or is the shift solely due to focusing on entry-level accessibility?

jamii 4 days ago

We built a Foursquare clone recently and the BOOM guys built an extended version of HDFS and Hadoop (http://db.cs.berkeley.edu/papers/eurosys10-boom.pdf). It works out pretty well. The shift is not really about accessibility either - I've watched people do some pretty advanced data work in fields like physics and biology.

It's more about making computers into personal tools. If you look at the tools the average person uses - email, excel, google etc - they all work really well individually but they are really hard to extend or compose. Each application is a world unto itself and doesn't play with the outside world. What would really help people work is not the ability to build their own applications but the ability to move data around and glue tools together. It's kind of like applying the unix philosophy to office suites.

Chiusano has a pretty interesting take on this - http://pchiusano.github.io/2013-05-22/future-of-software.htm...

 ibdknox 4 days ago

The shift is primarily due to the fact that relatively few people seemed to want to build large applications, including ourselves.

There are definitely some differences between building large apps and these more communication/analysis tasks, but we think the foundation itself applies to both. The language is an adaptation of the Dedalus[1] semantics, which the BOOM lab did some amazing things in distributed systems with [2]. If it can build a clone of hadoop, chances are it can build most things. We've built a number of our compilers in Eve, several of our editors were bootstrapped, we've built numerous examples, most recently a complete clone of Foursquare. Before we'd want others to try and do that though, we need our tooling to get a bit better. We expect that the Eve editor will get there eventually kind of out of necessity - we're going to bootstrap a lot of it this time too, starting with the compiler.

[1]: http://db.cs.berkeley.edu/papers/datalog2011-dedalus.pdf

[2]: http://db.cs.berkeley.edu/papers/eurosys10-boom.pdf

igravious 3 days ago

My take from the abstract of Dedalus is "and adds an explicit notion of logical time to the language"

If you're interested in building a tool that relies on distributed communication and data flow it makes sense to bake a notion of logical time into the the system. Boolean logic has no notion of time. If you propose x != y say, you could be saying that throughout the lifetime of the system x is never equal to y or you could be comparing x to y at this instant in time. It depends of course if these are constants and/or variables.

Type theory shows that different logics map to different type systems so what may be holding programming back is that the logic of a system is not _dynamically_ selectable as the system evolves. Most (all?) programming languages have a simple boolean logic, mutable state, and just tons and tons of syntactic sugar on top of that. Obviously languages like Haskell and Clojure are more advanced (algebraic data types in the former and immutable data structures in the latter) but they still have a fixed/static way of being in the world if you know what I mean.

Natural language shows us that humans use many different types of logic contextually. Logic is not monolithic, maybe Eve is an admission of this?

Sorry if this makes no sense, it's just a hunch that's been percolating for a while.

jamii 3 days ago

It makes sense, I think :)

Hickey's ideas about time and state are also pretty relevant - http://www.infoq.com/presentations/Are-We-There-Yet-Rich-Hic...

One of the things we are still working on is expressing non-monotonic logic nicely (things like "birds can fly, but penguins can't, but Harry the Rocket Penguin can"). It's unpleasant in standard datalog but I think we can provide a nicer interface.

hendzen 3 days ago

Is the endgame here making eve applications automatically distributed or parallelized?

I ask because the monotonic logic that Daedalus excels at expressing is quite limiting. Unless you are in an execution environment where operation ordering/synchronization is expensive (i.e. among a set of distributed processes) - the nice order-independent properties that CALM analysis gives you don't really buy you much.

jamii 3 days ago

I can't see us using CALM for anything in the near future. The focus right now is just on making the basic programming experience smooth. We chose Dedalus because the discrete, synchronous model of time makes it easy to separate things which are truly stateful from things which are not and to handle both in a live, interactive environment. CALM is just a bonus.

igravious 3 days ago

10 minutes into the Rich Hickey video and I can see why you responded to me with a link to it. This is indeed what I'm getting at; so many languages use fundamentally the same underlying logical and state model. Rich mentions single-dispatch, stateful OO. To that I would add boolean logic. Our systems or so riven by it we don't even see it. And I reckon it doesn't have to be that way! I can totally see why Eve is written in Rust from the 10 minutes of this talk that I've seen, and I can see that it is the incidental complexity of managing the lifetime of objects in your head in C++ that have forced this shift. Or, as per Hickey, Clojure-wards.

Still though, both Rust and Clojure, both presume an omnipresent bivalent atemporal logical discourse. If you're working on a different logic (or sets of logic?) in Eve then why not make them dynamically user-selectable at run-time in an intuitive manner :) Granted, I have _no earthly idea_ in practise what this means but when you reflect on how humans manipulate concepts internally you see that we have the machinery for this built into us -- or learnt somehow at a very early age. Tapping into this fluid logical apparatus would be ever so neat.

---

" 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? How hard is it to just write a program to read your emails and respond to certain ones automatically? As we dug more and more into the examples we collected from school teachers, programmers, nuclear physicists and lawyers, 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. 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. " -- http://www.chris-granger.com/2015/08/17/version-0/

---