Eve is a programming language and IDE based on years of research into building a human-first programming platform. From code embedded in documents to a language without order, it presents an alternative take on what programming could be - one that focuses on us instead of the machine. This is Eve:
We've made tremendous advancements since the early days of programming, but the modern form still forces us into the role of bit shifting machines. Programming has always been for us - the humans tapping at keyboards. The computer doesn't care what syntax or semantics we use or how error messages are phrased. Those are for you and me. And this is how we treat ourselves...
Focusing on the machine and ignoring the human factors of software engineering have led us down a difficult road. From inscrutable error messages to semantics that require years of study to understand, we've landed on a version of programming that is actively antagonistic toward our goal of creating usable and robust software. To make matters worse, we're programming as if we still had the 1970's computer that our tools were developed for. Unsurprisingly, we are struggling. A lot.
There's no reason we have to stay on top of a sinking foundation though. What if we went back to first principles and put humans first? What would that look like?
Over the past several years, we've been exploring what an alternate future could look like and have distilled that research into a platform that we call Eve. To get a taste, let's take a look at a day in the life of someone programming in Eve:
The first difference you'll notice is that programs look more like word documents than code files. Eve is designed for "literate programming" - instead of comments embedded in code, code is embedded in a document.
This gives us the freedom to organize our programs based on how we actually think, not how the code will be compiled. We can group blocks based on functionality, similarity, owner, or anything else we can think of.
More importantly though, it gives us the ability to weave a narrative of not just what the program does, but why it does it. You can write a spec and then embed the blocks of code that make it work. Someone new to the project can look at the table of contents to get a sense of what's going on and then dig into a section to add something. Instead of constantly trying to piece the narrative back together every single time we fix a bug, we can make it an artifact of programming in the first place.
eve doc
The environment we want in this context is more about narrative creation than class hierarchies. We want a reading and writing environment that allows us to meaningfully lay out and explore our program. The first step towards that is having a table of contents that provides both an outline and a convenient form of navigation.
But just because we have a linear representation of the program, that doesn't mean we can't view it in other ways just as easily. Instead of a slew of tabs and complex navigation features, we have a document that arranges itself in whatever shape we need. And as much as possible, everything is placed in context so that the narrative is kept front and center.
errors
