ibdknox

I have stated from the beginning that I'm more than happy to get people more involved. When it has come up before I've said I'd gladly give people commit rights. There are only a couple of people who have contributed with any degree of frequency where that would make sense - Josh Cole and Mike Innes come to mind, for example.

I will certainly not stand in the way of the community and we're more than happy to help maintain.

Hey Evan, I have immense respect for your work, but this is surprisingly armchair quarterbackish.

> "The competition has millions of man-hours invested". Who cares? On a day-to-day basis I execute maybe 3% of the code paths in my editor

This is the Microsoft Office argument and the problem is that no one uses the same 3%. If they did, sure it'd be "dead simple", by that of course I mean take many, many years of work. Sublime which attempts to do far less than we wanted to took 5 years to get to today and I'm not sure it really is a commercial success capable of supporting 3+ people.

> "Programmers don't pay for software". I'm sorry, but this is a poor excuse

It's far from an excuse, it's the truth. It doesn't matter if developers as a class have a lot of money. They don't actually spend it. I don't know a single person who has ever personally paid for Visual Studio. Github is a service and the vast majority of their money comes from companies not individuals. How many people run stuff only on the heroku free tier?

Or here's a direct example: when we launched the kickstarter people \freaked\ out about us pricing it at $50. We had to drop it all the way to $15 and folks still complained endlessly about it. It is well known that short of a service targeted at companies, it is near impossible to sell developer tools. After all, it's a group of people who look at a piece of software and say "I can build that".

If there's some secret, we're missing it. There's an entire organization [0] that has grown up around trying to help dev focused companies figure this stuff out. It's led by James Lindenbaum (co-founder of Heroku, invested in us), he knows his stuff and he couldn't figure out a way to make this work out either.

[0]: http://heavybit.com/

Just to be clear: this is not Kickstarter funds being redirected. We worked on LT for 2.5 years, we were given 280K (after KS's cut), around 20k went to shirts/fullfillment. That's 260k for 3 guys in SF over 2.5 years... that money ran out long ago.

> And, in doing so, he focuses on not needing the guy that knows a particular language

That's a pretty narrow way of reading what I was saying. What I meant is the one guy who knows how to program and I just happened to pick Python because that's the common case in science. Do you really think a mathematician, biologist, or chemist can't think through a logical approach to solving a problem? I certainly believe they can, the problem is then in translating that to the computer. Right now, that would mean knowing (pick your programming language) and translating that logical solution. We want to make that way, way easier, to the point where it's like using the tools you already do to do this stuff (Excel).

> Its all pretty vaguem, anyway, and the further clarification on the thread sounds like the goal is the yet another app builder

We've bootstrapped the editor, parts of the incremental compiler, parts of the platform, the domain editors, etc. If you can do that in an "yet another app builder", I'd definitely love to see it. We're picking one domain to focus on because that's how you grow a product, but at the end of the day, if it doesn't suit my needs as well, I certainly can't call it a "better programming" in general.

Yeah, I think that's a fair way of thinking about it, especially since we drew a lot of inspiration from Hypercard itself.

> but it's very rare for tools alone to lead to a new paradigm

I think the distinction is that a tool helps you do something more efficiently while still generally thinking about the problem in the same way. What we're proposing is a very different way of thinking about the problem, which is what I think starts to define a paradigm. That being said, this is largely semantics and not a very valuable thing to argue about: paradigms come to be by the accident of use, so we'll find out when we launch and build a community around Eve.

FWIW, I've mentioned in a few comments below that our first in-road here is just building websites. You can think of it as a replacement for VB6: something a normal person could use to draw out your application and then describe what happens when you interact with it.

The rest comes later, though we do believe it all flows out of a common model for programming in the same way that all of those things could come from any general purpose language.

I was suggesting that it's actually not like labview at all :p

The model we have is significantly better than what we ever showed with Light Table. For example, being able to organize "code" by the actual functionality it's related to instead of files is something that happens by default in our world. You can actually create queries to show any view of the rules that exist in our world that you want (show me everything related to this button, that has been changed in the past month..)

Our model is entirely about preventing people's heads from exploding, taming complexity through a very simple set of primitives that seamlessly work together.

I personally don't have much of a math background, but Jamie does (he went to Cambridge for it). FWIW, Eve is actually very heavily based on mathematics and using first principles there to guide us to a solution that is backed by more than just intuition.

A lot of our overarching design is based on things they laid out in Out of the Tar Pit :)

We're doing some clever stuff between constraint layout and relative layout that will make a lot of that concern disappear. We also intend to present this as almost a statemachine, or a storyboard where you see the various states of your UI laid out, which gives us an opportunity to surface a lot of the "unseen" aspects of UI.

> If you continue on this path, you will leave behind a trail of half-baked tools, each one a great concept, but none of them actually useful.

FWIW, I agree with you. This is our path, though, and the funding and the people we've brought on to work with us prove that. We're locked in to Eve and we think it will ultimately have far greater and for more lasting impact than LT ever could.

So the best I can say is that we're all in on Eve (both personally and now as a company) and I think that's very important for this to have a chance to succeed.

Juno is fantastic and we'll help them do whatever we can with LT.

It depends on how you use the term "visual programming language", which unfortunately has a lot of baggage around it. It is not sticking lego blocks together like Scratch or LEGO Mindstorms, nor is it the boxes with arrows pointing at eachother like Max MSP/Lab View/Blueprint/noflo, but it's also not strictly textual. The closest analog really is Excel or Access, but with the ability to describe how you translate one sheet/table to another one. Your main interface is a grid of data and a list of output tables. On top of that sits a set of domain editors though, to make drawing UI, for example, not an exercise in writing a bunch of rows out into a table. Instead you use a photoshop-like tool to just draw your UI. Same with doing math or string operations or flying drones or working with music and so on. We of course can't cover every domain, but what's interesting is that the editor is itself kind of like an editor of editors and it'll make it fairly trivial for you to build your own manipulable representations.

We renamed Aurora to Eve, though it's changed significantly since that video. We found lots of issues with that way of thinking about the world and so worked to find a better model. The name Aurora didn't seem to test very well, but we've found Eve to work rather nicely.

As just a plain editor, it's hard to compete with vim/emacs/sublime. The interesting things LT offered were around connecting to running pieces of software and the truth is that we just ran against a wall in what we can do with our current languages. That's why Apple's effort with Swift is so important: they're designing the language to be tooled. We didn't have that benefit and along the way we learned that it actually wouldn't help that much anyways.

Any single tool is going to be an incremental improvement (at best) on programming, because the source of the issues is really the model itself. My suspicion is that programming is going to change substantially over the next decade, because while we've been worried about machine learning, rails, and hadoop, the notion of the machine changed out from under us. We're already starting to hit a wall as a result of that - reasoning about highly concurrent systems with the programming models we have now is nearly impossible. If we continue pushing LT for that way of thinking, it's unlikely to make much of a difference. Instead, there's an opportunity to embrace that change and take the ideas of LT to their logical conclusion: what would a stack built for today's machine that is meant to be used by humans look like? We stumbled on a solution as we did more and more user testing of LT and in the interest of self preservation we ran with it.

More practically, though, incremental improvements are hard to sell - not just to VCistan, but to programmers as well. Hell, even orders of magnitude improvements are hard to sell to programmers. We'd have no way of sustaining ourselves if we couldn't find some avenue to eventually turn this into a business - we looked and couldn't really find a reasonably quick way to do that. Matching the millions of man hours that have been poured into vim/emacs and so on is just not in the cards for a couple of guys with not much funding. Plus it seems programmers are increasingly less interested in paying for anything in general, so that didn't make our prospects all that attractive. With Eve there's a much clearer path towards creating a sustainable business that is able to continue towards the ridiculous goal we set out with from the beginning: to empower the world's creators.

We use LT every day. Lots of other people do too. It fills an important part of the ecosystem and we hope it continues to infect other tools and organizations who have significantly greater resources than a couple of guys in SF. But either way we will do our best to make sure that it continues. Unfortunately, though, it just can't be our primary focus - both because I think that would be focusing on the wrong part of the problem and because at the end of the day we have to pay ourselves and there's just no way for us to do that.

Our first bastion is websites, you can think of it as filling in the gap that Microsoft left when they killed VB6. 15 or so years ago, someone could open up VB6 draw out a couple of forms and put together a simple "Line of Business" app themselves without having spent 10 years of their life becoming a professional programmer. The modern VB6 would do the same for websites. :)

> Unless Eve brings a 10x improvement to those tools

We know the bar is pretty universally an order of magnitude and so we've planned accordingly. Our primary target here is selling a super power: you couldn't do this at all before, and now you can. Joe in accounting doesn't have the opportunity to build things to support himself (short of studying programming), but with Eve he could do everything from automate several of his workflows, to building a dashboard, to building dynamic reports for his bosses, to creating internal tools to track and measure things.

There is a fairly clear gap in our ecosystem around these kinds of programs and they represent what I would argue is the vast majority of programs that should be written, but aren't because of the cost.

There's also the opportunity to just make websites an order of magnitude easier to build for programmers and we're getting there. I was able to write an entire editor for this thing in itself in a week for one of our prototypes - there's some real potential there.

We're shooting for a big reveal early next year.

haha it's funny, this is almost always the first worry programmers have after we talk about Eve.

Don't worry, we'll make sure it works whether you use the mouse, a keyboard, maybe even a touch screen or voice. :)

We've been waiting to announce the news for a while now. Can't tell you how happy we are to finally get it out.

We're tremendously excited about the potential we have with Eve and everyone we've talked to about it so far leaves with their head reeling. There's been an undercurrent brewing in the programming community that we're approaching a sort of transformational point in the way software ends up built. We hope to be part of that transformation.

I don't talk about it a ton in the post, but Eve isn't just about giving the Excel generation a seat at the table, but it's also explicitly designed to get us back to what we do best: solving problems. There are some pretty amazing properties that fall out of simplifying things as much as we have: concurrent by default, a real shot at auto-parallelization, a debugger that can tell you when, why, and how a value came to be, diffs not of code but of the output, the chance for true real-time collaboration on software, introspection into every part of the system, and so on. We'll be talking more about how it works over the next couple of months, but I can promise you now: there's some exciting stuff coming for all of us.

As always, in the interest of sharing with the community who helped us get here, I'm happy to answer any questions!

That's correct. There are so many things we'd love to do with LT, but the truth is (as Sean knows quite well) our current programming models simply don't support a lot of the experiences we should have.

We started to hit roadblocks with our current paradigms and we happened to get lucky enough to stumble on some ideas that could move us forward. What we're working on now is the foundation necessary to do things we've always wanted to do (and awesomely, far more).

We'll be announcing some cool stuff soon, but the gist is that we have to look at the whole stack to find something better. So that's what we're doing.

My original goal wasn't ever to really create a visual programming environment, though the mismatch here might just be us using the term "visual" differently. We wanted to make something that allowed people to create whatever representation of their code/project/etc they want, but I didn't really expect that to ever turn into code generation via graphical media.

Code Bubbles isn't visual programming as the term is typically used, it's just a way of organizing text in a more meaningful way.

I'm not sure where $6M would carry a team of 30 for 4 years, but it certainly isn't in any of the tech hubs. Total cost for an employee around SF is between $150-180k (office, taxes, benefits, etc). For the sake of being generous, let's say we're in Seattle and it's 120k:

120,000 * 30 * 4 = $14.4M

Even at 60k total cost you break 6M in 4 years:

60,000 * 30 * 4 = $7.2M

> It's big for the average series A for YC

That's not true, it would be huge for a Seed, but that's a fairly middle of the road series A. Big would be in the 10M+ range.

This is a great example of the magic of open source. He took a project I haven't touched in almost 3 years and made something wonderful out of it. That may very well have never happened 10 years ago.

Awesome work Shaun, thanks for contributing back to the ecosystem.

We hope to do a big reveal early next year, but we'll probably be talking more about the technology between now and then. :)

What is the missing piece that ML brings to the party? I can certainly see lots of neat opportunities for ML tie in with the system we're building, but I can't think of anything that would end up relying on it.

Hm. I said it was sad, not wrong.

Let's say you take direct inspiration for something you're working on and you know someone's been there and thought a lot about it. Wouldn't it make sense to ask them about it? It's certainly true that some mistakes are better learned by making them yourself, but a whole lot aren't. Hell, half the time it's just stuff you're too close to see anymore.

The Swift playground is strikingly similar to many of the things we've done in Light Table. It's wonderful that Apple is taking that and running with it and I want these things to end up out there and make things better for devs. But I could've helped them skip some of the crap along the way and I've worked with other large organizations to help them do exactly that.

> To suggest that your opinion is more valid than theirs is hubris.

My opinion is no more valid, but given that their work looks fairly like our own, I certainly have the benefit of past experience. This isn't about hubris. I have a unique perspective in this particular case, one that no one else will have, as the creator of one of the things they were "heavily influenced" by. I'd rather they took advantage of that so that they can continue to push things even further and not fall into some traps that we did at Microsoft and with LT itself.

In any case, I'm sorry I seem to have offended you. My goal is not self aggrandizement, it's just to help do my part in making things better for us all.

fwiw, he had no direct involvement in it. http://www.quora.com/Did-Bret-Victor-work-with-Apple-on-the-...

The only thing that makes me sad is that because of their focus on secrecy, they're doomed to relearn all that we learned along the way. Having played with the swift playground stuff, just an hour long conversation could've made a big difference.

Such is the way of Apple though.

Yeah, we're working on something much more interesting than Swift, which while cool appears to be just more of the same thing we have now. We've questioned a lot of assumptions and come up with a system that is very different than the way we tend to think of programming currently. The benefits you get from going outside of that box are pretty crazy and we're working furiously to get to the point where we can start showing it to people.

> The harder part is getting enough programmers to care, even if they come out with something really revolutionary.

That's true, but even programmers will have a hard time ignoring some of the claims we'll be able to make :)

In any case, our work on Light Table is a small step compared to where things are headed and at the very least, I can promise there are interesting times ahead.

Highlights for the TLDR crowd: multiple cursors and improved editor performance.

I know many of our users/contributors are from here so thanks to all of you for the awesome involvement we've seen. You guys rock :)