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.

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.

> 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)

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!

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?

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.

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?

> 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...

But if you want to do a "dashboard proper", you can use the Power BI tool: 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.

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?

A few other things to check out in this realm:

http://unisonweb.org/

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

http://www.subtext-lang.org/

http://www.cs.virginia.edu/~evans/cs655/readings/smalltalk.h...

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/ (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) right now haha.

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?

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.

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!

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

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.

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.

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.

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 && cd eve-vagrant

$ vagrant up #this may take a while

$ xdg-open 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 && cd eve-vagrant/partial

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

$ xdg-open http://localhost:8080/editor ```

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?

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.

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

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

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!

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

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

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.

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!".

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).

Is anyone using LightTable on a daily basis?

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

Confusion reigns. They should call it Evie.

I wonder if he will finish this one...

"topmind" strikes again!

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

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

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.

I'll be happy when it gets vi keybindings

> 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.