
The Eve programming language project is winding down - mrry
https://groups.google.com/d/msg/eve-talk/YFguOGkNrBo/EozaCfheAQAJ
======
jonathanedwards
We need to have a conversation about the possible paths to make programming
more widely accessible. Chris saw the problem clearly and tried to fix it.
Respect. I am most impressed with the number of iterations he was able to
crank in the context of a startup. But ultimately a startup may not be the
best place to start, because low-end programming is not a short-term growth
play. We have to play the long game.

~~~
linkmotif
I think the conversation we should have is why we make everything seem so
hard. What a bunch of hooey.

In 5th grade everyone talked about how Algebra was hard. When I got to
Algebra, it was pretty easy. I was very surprised! Of course my dad had to
explain it to me, because my teacher was incapable of explaining it.

10th grade, same thing with calculus. Thank god my dad knew calculus and was
patient. Because my teacher did not.

And so on and so on.

One thing I’ve noticed is that nothing humans have invented or discovered is
hard. Learning things requires curiosity, a lot of patience, and someone
showing you how to get from A to B in small steps. Overwhelmingly, the
inventors and discoverers are the people at the bleeding edge of those small
steps who find a next step.

Programming is no different. We need to stop infantalizing people. Most humans
are incredibly capable. We don’t need programming languages for children. A
child can learn Python or JavaScript. You just have to show them that it’s
cool. But instead most adults show kids that sports, video games and Netflix
are cool. So, c’est la vie.

Today unfortunately we have a culture of “you can’t, it’s hard, it’s not for
you, other people do that.” People always refer to “they” when they’re taking
about people inventing something. This is good for the rich and easy for the
poor. Who is “they”? What if instead of “they” it was “we”?

~~~
pjmlp
What helped me to learn programming as a 10 year old child, was the 80's
programming books targeted at children.

Always full of drawings, or little stories, and along the process I got
introduced to BASIC, Z80 Assembly and all the intricacies of Spectrum
hardware.

I used to think those books were gone, but they seem to have come back
regarding Arduino and Rasperry Pi programming. Just focusing on Python and
Scratch now.

Giving them a board with such books and some electronic stuff is probably the
best way to teach them. Regular computers have too many layers that just
hinder learning and its hard to see things happening.

~~~
exikyut
The massive problem is, learning Z80 assembly for the Spectrum was tricky, but
not overwhelmingly so.

The C64, the Spectrum, the TRS-80, etc, were all "small" machines that were
simple to learn.

The Arduino, Raspberry Pi and Scratch are also tricky, but not overwhelmingly
so, and simple to learn.

The absolutely massive difference with the environments of the 80/early 90s
and today is that

a) The environments learned are heavily sandboxed, caricaturized facsimiles of
computing

and

b) Learning Scratch won't lay down a mental model you can immediately apply to
Python, and learning Python won't lay down a mental model you can immediately
apply to C++, Rust, etc.

Learning assembly language didn't quite leave you with an immediately-usable
understanding of C, but what it did do is give you a working knowledge of what
everything else was based on under the hood. I'd argue that's an even more
valuable gift: the knowledge that you understand what the more complex
environment is based on - good for confidence - and the knowledge that if you
absolutely need to, you can pull everything to bits and unravel bits of it -
which immensely helps with discovery.

Nowadays, it's like worst-case simulated annealing. "Climb Mt Everest, then
climb all the way back down to climb Mt Everest²."

~~~
Sean1708
> Nowadays, it's like worst-case simulated annealing. "Climb Mt Everest, then
> climb all the way back down to climb Mt Everest²."

I don't think that's a good analogy, I think it's more like "Climb up to base
camp, then climb halfway up, then climb ...".

I learnt Python before I learnt C and learning C I was constantly having these
"Aha!" where I suddenly realised why Python is the way it is. I didn't have
one mental model for Python and a different mental model for C, I had one
mental model for computing which was enhanced by learning C.

And on top of that Python isn't a fundamentally different language to (for
example) JavaScript, sure the details differ but somebody who knows Python
won't have to spend months learning JS. Arguably a language like Haskell _is_
a fundamentally different language to something like C, but there are plenty
of things that you learn when learning C that can be applied to Haskell.

I don't think the issue is all these concepts are orthogonal, I think the
issue is that there are just so many concepts. Back in the 80s learning
assembly might have got you 30% of the way up Mt. Everest, whereas nowadays it
might only get you 1% of the way up.

------
RcouF1uZ4gsC
While Eve is an interesting problem, the main issues that makes programming
hard are the same thing that makes law hard:

1) Specifying something in an unambiguous way.

2) Knowing what assumptions you are making.

3) Anticipating contingencies.

Read a contract or the tax code. Even though they are using English (in the
US), it requires an advanced degree to be able to craft such legal documents
well.

It is the same thing in software. No matter how easy and intuitive you make
the language and environment, you will still run into those 3 issues, and it
will require dedication, training (whether formal or informal), and time to
make a great programmer.

~~~
indubitable
Another good example of the issue here is any programming language that was
meant to be able to be read/used by non programmers. SQL is a great example
there in my opinion. The syntax and structure is clearly meant to try to mimic
relatively natural language, yet in practice I think SQL is vastly more
challenging and complex than most any programming language intended to be used
by programmers.

Of course this goes all the way back to all the programming language that used
to be used around the time of SQL's development, such as things like COBOL.
They're just really tough to work with, even for those of us who learned it as
one of our first languages. Anecdotally at least C structure languages now
feel 'natural' to me, whereas the natural language programming languages
always felt (and feel) like trying to fit a square peg in a round hole.

~~~
dragonwriter
> The syntax and structure is clearly meant to try to mimic relatively natural
> language, yet in practice I think SQL is vastly more challenging and complex
> than most any programming language intended to be used by programmers.

I don't; and the fact that I've known plenty of people who are not programmers
before and do not consider themselves such afterward who have picked up SQL
fairly quickly seems consistent with it not being that much of a barrier.

I think SQL had some design decisions that are particularly frustrating to
_programmers who are familiar largely with currently popular general purpose
languages_ , though.

------
d--b
I'm sorry to say but I am happy to see that this is coming to an end.

These guys have delusions of grandeur. At best, they're good researchers
looking into new and simpler programming paradigms. But the way they're
talking about it is just horrific to me. It's full of "imagine a world where
you could just..." and "we're building that world for you" BS.

I just hope Eve's failure is going to be a lesson in humility.

~~~
airstrike
That's standard startup speak, though. How else are you going to get investors
and early adopters excited? Everyone is competing for everyone else's fleeting
attention this day and age.

~~~
klibertp
> That's standard startup speak, though.

That's exactly the problem: building a programming language doesn't fit - I
think - into the startup framework unless you're prepared to be in stealth-
mode for a decade. Even the biggest tech companies have problems with making
their languages mainstream - for every success-story like Go or Swift we have
some kind of Dart or Dylan that simply didn't work out, despite companies
investing massive resources into them.

> How else are you going to get investors and early adopters excited?

With a programming language? It's easy: have a good, battle-tested codebase
which implements your killer features efficiently and correctly, supports non-
primary features just as well, and has a huge collection of written (open
source) software/examples in that language.

That's why I think PLs are not easy (or maybe even impossible) to make into a
startup. LightTable had a _much_ higher chance to work out, IMHO, because it
was well-defined, was not without precedent and some other similar projects
proved to be viable businesses (for a time).

EDIT: I forgot, the Red[1] lang team tries to do something similar, ie. write
a language and be a profitable company at the same time; we'll see if they
manage, but then again, they are looking to "just" displace REBOL instead of
"revolutionalizing the way you think about programming" (again).

[1] [http://www.red-lang.org](http://www.red-lang.org)

------
amasad
I've always admired Eve but thought it was a longshot. Had it worked it
would've changed the future of computing.

I'm also working on making programming easier but instead of taking a moonshot
approach -- where you build the language, the IDE, and the tools -- we're
making existing tools and languages easier to use.

I hope Chris doesn't give up, there's a lot more to do.

~~~
juancampa
For context, amasad is the founder of repl.it

------
ModernMech
For anyone interested, here was Eve in its last incarnation:
[https://www.youtube.com/watch?v=zenELksXotI](https://www.youtube.com/watch?v=zenELksXotI)

~~~
drcode
I really want to like this, but it's really not much more impressive than
this, once you take into account the fact that the author clearly memorized
the exact demo steps:
[https://www.youtube.com/watch?v=UIZO1TKPlzY](https://www.youtube.com/watch?v=UIZO1TKPlzY)

~~~
swsieber
I think it's 1000x more impressive - you get to see it in action live. How
that scales up to more complex things though, I'm not sure...

------
pbiggar
As someone making something in the same general space as Eve, very sad to see
this happen. Thanks for taking a shot and proving that there are other ways of
thinking about programming!

Looking forward to the writeup.

~~~
chubot
Just curious what's the general space that Eve is in? Programming environments
for non-programmers?

I applaud the ambitious efforts of both Eve and Light Table -- it's definitely
worth trying, and the negative result is valuable too. But part of me wonders
if they were tackling too big a problem, or at least MARKETING a (potential)
solution to too big a problem.

IIRC, I believe they figured out through talking to users (which they did,
which is good!) that most people want to do stuff with data. For example,
teachers might want to do some simple analysis of homework assignments and
students. And there are many tasks that fall into the category of what you
would do with "mail merge" in Word or a macro added to an existing
spreadsheet.

I wonder if they would have had more success by nailing a narrow use case and
expanding outward. The marketing always felt too "general". I feel like a lot
of non-programmers want to get their jobs done more than they want to learn
programming. You probably have to trick them into programming. Even 10 or 20
hours of up front "learning" is too much.

FWIW, I've worked with technical artists in games (e.g. writing MEL scripts in
Maya), and statisticians doing big data (e.g. writing R), so I have thought a
lot about non-programmers programming. And I've also looked at and modified
their code.

There is probably a more polite way to ask this, but I think it has to be
asked. How many people in the world have the IQ to write a program of say 100
lines that does something useful? If you have a job as a technical artist, a
statistician, or an actuary, I think you fall in that category. (On the other
hand, it's also true that not everyone with those jobs can write a program
that works, let alone that can be maintained by their coworkers.)

But there are plenty of people who can barely use computers. I remember that
my former boss (a very empathetic man) was recruited by a neighbor to teach
his son programming. The son played a lot of games, and was interested in
making games. And my boss's realization was: "this person needs to learn how
to use a keyboard and mouse first".

I think with the rise of phones and tablets, you might see basic skills like
text editing going down the drain. Contrary opinion: if you don't have the
patience to learn how to use a text editor to say write HTML files, you don't
have the patience to learn programming OF ANY KIND, even visual programming.
(Incidentally, there is a similar inspiration behind Raspberry Pi -- basic
skills like knowing how hardware works had gone downhill for Cambridge
students since the 80's.)

Anyway, this was a random bunch of thoughts, from someone also working on a
programming language. But I'm working on a language for experts, not for
beginners. (It's better Unix shell, which both developers and non-developer
professionals -- like sys admins, data scientists, technical artists -- use.)

The point is that I'm wondering what space Eve was really in. When I look at
their website, I see

 _A moonshot to make programming accessible to everyone._

[http://witheve.com/](http://witheve.com/)

That doesn't tell me very much. If it's for everybody, then it's for nobody.

I've always liked these observations from Paul Graham, which I've quoted here
before:

 _You can 't look a big problem too directly in the eye. You have to approach
it somewhat obliquely..._

[http://www.paulgraham.com/procrastination.html](http://www.paulgraham.com/procrastination.html)

 _Let me conclude with some tactical advice. If you want to take on a problem
as big as the ones I 've discussed, don't make a direct frontal attack on it.
Don't say, for example, that you're going to replace email. If you do that you
raise too many expectations. Your employees and investors will constantly be
asking "are we there yet?" and you'll have an army of haters waiting to see
you fail. Just say you're building todo-list software. That sounds harmless._

[http://www.paulgraham.com/ambitious.html](http://www.paulgraham.com/ambitious.html)

So basically I think it would have been better to just tell everyone "we're
making a better mail merge" or "we're making better excel macros", or even
just a better SPREADSHEET, which is itself huge enormous problem, but actually
smaller than "programming for beginners".

Then you'd be helping them get their jobs done without all the programming
mumbo jumbo. But the whole time you could be trying to generalize it into a
way of programming in other domains, for programming "in general". Just like
Python can be applied to many domains.

\-----

Also, even if you SUCCEED at making a better language/IDE that subsumes what
people do with mail merge, excel macros, and every spreadsheet in the world,
you HAVE NOT succeeded at overhauling programming! Programming is a very big
field now!

There are / will be languages for distributed computing with various
consistency guarantees, languages for computing with privacy, with security,
languages for quantum computing, languages for machine learning. Those will
not be touched by something like Eve or Light Table.

That's one of the reasons I'm interested in shell -- because in many contexts,
it's the lowest common denominator that connects all these different domains.

~~~
BoiledCabbage
> . How many people in the world have the IQ to write a program of say 100
> lines that does something useful?

Have the IQ necessary? Probably 90-95%.

Have the training? Significantly lower. The training required consists of both
being taught a language/medium to express thought it, and being taught a
structured cause and event method of thinking.

There's this incredibly pervasive view in a lot of areas that programming
requires some amazing IQ. It requires about the same level of IQ as reading &
writing. But just like reading and writing, it requires training, and from a
younger age the easier. If someone wants to approach it later in life, then
having already learned or being familiar with transferable skills and thinking
helps immensely.

~~~
ModernMech
This is actually the thesis behind Eve. Humans are incredible problem solvers,
and we did it for millennia without computers. Computers are great tools for
problem solving, but for many problems they are obtuse not because they are
inherently hard, but because we have made them unnecessarily so. Take away all
that ancillary complexity, and you're left with a tool and the essence of a
problem. Most reasonably intelligent people should be able to take it from
there.

~~~
kamaal
>>Humans are incredible problem solvers, and we did it for millennia without
computers.

Some humans are incredible problem solvers. Most are not, and most importantly
don't want to be.

------
yinso
Programming languages for non-programmers needs to be embedded in a vessel.

Excel is probably the quintessential vessel. When people are trying to solve a
need they have, they will invest the effort to figure out the tools, including
learning enough programming to solve their problems.

~~~
dragonwriter
The Eve team emphatically, from day one, had this stance.

It is perhaps indicative of a key strategic error that the course of the
public work on Eve did not involve as clear as picture of the target vessel as
of the programming language, especially given the churning on the PL
implementation that dominated the last phases of the public effort at Eve.

------
robertkrahn01
I'm very sorry to see this. We need investment in programming language and
environments – and right now there is pretty much zero of it. No, new
programming concepts and tools will not pay of immediately but in the long
term they can be incredible efficiency multipliers, empowering pros to do more
work in less time and non-pros to be programming in the first place. As long
as no one is interested in funding this kind of research & development we stay
where we are today.

~~~
lucozade
> and right now there is pretty much zero of it

There's huge investment in programming languages and environments. It wouldn't
surprise me if there's more than there has ever been at any one time.

And it's entirely healthy that some fail. That's a primary means of learning.
I would anticipate that some of the ideas from Eve will find their way into
other environments, as did ideas from LightTable before it.

~~~
robertkrahn01
Where? The state of the art today of

\- debugging

\- code browsing, system exploration

\- customizable, modular, non-textual user interfaces*

\- immediate feedback after code changes

\- non-textual programming

is < what Lisp and Smalltalk environments provided more than thirty years ago.

* not necessarily visual programming. Look at the Genera Lisp OS or Plan 9 for example.

~~~
lucozade
Languages: Swift, Go, Rust, Julia, Haskell, JS, C++ etc etc

Dev envs: VSCode, Electron, more build systems than you can shake a stick at,
VMs, containers, playgrounds etc

Non-textual programming. For general purpose programming, I can't think of
any. There are some dead ends that will probably remain so. For niche
programming, there are loads.

And to my point, Lisp, Smalltalk and Plan 9 are all good examples of failed
experiments that folk took ideas from and used in subsequent projects.

Now, you may not like the investment and innovation. It may not be what you
had in mind. Each to their own. But there's plenty of investment and no small
amount of innovation.

~~~
nikofeyn
labview is a general purpose visual programming language. it's as general
purpose as, say, python. it's just different and proprietary.

~~~
lucozade
That's fair. Same can be said for some of the educational tools too.

More of a cul de sac than a dead end.

------
_halgari
Kind of saw this coming after the third reimplementation in yet another
language. And why Rust? 2 years ago they decided to use Rust to implement a
new language (IIRC Rust wasn’t even 1.0 at that time). That’s a huge amount of
technical risk.

I wanted to be exited about eve, but it was always too light on details, had
too much risk to ever allow it to succeed, and after several pivots it failed.

This story probably been a bit different if only it was a bit less ambitious,
and a lot more pragmatic.

------
scrumper
Oh, sad. I always get very excited about the stuff Chris does, it’s right on
the interesting corner of the leading edge. I hope whatever comes next is a
combination of his ideas which finds fertile ground.

------
ursus_bonum
FlappyEve inspired my first "Tiny C Game", Flappy, now part of
[http://TinyC.games](http://TinyC.games)

------
ilaksh
They made some really cool tools. The tools did not end up being a financial
success or mindblowingly popular like a mainstream programming language, but
they were still relatively popular. In that a lot of people at least know what
it is. Most projects, no one even knows they exist.

Don't confuse popularity with merit in general, or not becoming massively
popular with not being successful.

------
akavel
If you're interested in some other recent attempts at new approach to
programming, I'd personally suggest having a look at:

[https://luna-lang.org](https://luna-lang.org)

that had a first public (beta) release just this month.

(I'm not associated, just personally have a strong belief that it is a
breakthrough technology.)

------
steveklabnik
A sad day. Eve is/was really, really cool. I was looking forward to watching
it grow.

I wish PLT was a viable path for more programmers.

------
zubairq
As an Angel investor on the Eve project even though I lost my investment, I
think that Chris, Robert and the whole team deserve recognition as they
changed the whole industry, and now everyone is following them. I am proud to
have had the chance to be involved with them!

~~~
adwn
> _as they changed the whole industry_

Huh? What industry are you talking about? The software development industry?
Their influence was not even a rounding error. The let's-rethink-programming-
completely industry? No idea, but that's not really an industry.

~~~
zubairq
They influenced swift and a whole bunch of other interactive IDEs with the
research they did. Don’t use iPhone or Android if you don’t want to use these
new languages

~~~
adwn
> _[...] if you don’t want to use these new languages_

I'm stumped – where is that suddenly coming from now? When did I say anything
about not wanting to use Swift?

~~~
zubairq
Light table/eve was one of the influences for swift

~~~
diggan
The only quote I can find about swift and Light Table is this:

> The Xcode Playgrounds feature and REPL were a personal passion of mine, to
> make programming more interactive and approachable. The Xcode and LLDB teams
> have done a phenomenal job turning crazy ideas into something truly great.
> Playgrounds were heavily influenced by Bret Victor's ideas, by Light Table
> and by many other interactive systems.

From: [http://nondot.org/sabre/](http://nondot.org/sabre/)

And that just mentions "Playgrounds", which seems to be some sort of editor
application written in Swift. It did not inspire Swift itself.

And also, Swift hardly "changed the whole industry", as far as I know.

~~~
zubairq
Nice link by the way. I was more referring to this published by The Atlantic
(incidently owned by Steve Jobs family trust):

[https://www.theatlantic.com/technology/archive/2017/09/savin...](https://www.theatlantic.com/technology/archive/2017/09/saving-
the-world-from-code/540393/)

[https://www.recode.net/2017/7/28/16055162/laurene-powell-
job...](https://www.recode.net/2017/7/28/16055162/laurene-powell-jobs-
acquired-atlantic-magazine-publisher-steve-widow-philanthropist-nonprofit)

Sorry this thread flamed up a bit. I was just trying to express my gratitude
to the Eve guys

~~~
diggan
No worries, I understand and have gratitude towards the folks working on it as
well. But I don't agree with that they changed the entire industry.

The second link you posted mentions nothing of Swift. The first one has the
following quote about Swift:

> The default language for making new iPhone and Mac apps, called Swift, was
> developed by Apple from the ground up to support an environment, called
> Playgrounds, that was directly inspired by Light Table.

Which seems to agree with the previous quote I posted. Light Table inspired
Playgrounds, not Swift.

~~~
zubairq
yeah, good point. Sorry I said Swift, but I meant Playgrounds. I guess I see
Playgrounds as the interactive IDE part of SWIFT, like Visual Studio is for
C++, so I don't really separate the two in my mind. Anyway, we can agree to
disagree on the other point, I just like the discussion :)

~~~
wll
Kickstarter uses “Swift Playgrounds for iterative development and styling.
Most major screens in the app get a corresponding playground where we can see
a wide variety of devices, languages and data in real time.” (The Kickstarter
iOS app is open-source [0]; see their playgrounds [1].)

Here’s [2] Brandon Williams’ talk Finding Happiness in Functional Programming
(starts at “Playground-Driven Development,” but I suggest watching the whole
talk), [3] the Swift Talk episode “Playground-Driven Development” (Brandon
Williams and Chris Eidhof), and [4] the Swift Talk episode “Test-Driven
Reactive Programming” (Lisa Luo and Chris) wherein they build a small but
complete PoC all within Playgrounds.

There are many more examples, such as Chris Lattner’s own Dynamic Member
Lookup proposal [5] Python Interop playground [6] and Reactive Swift’s getting
started playgrounds [7].

Playgrounds are very much entangled with Swift’s core (value proposition).

[0] [https://github.com/kickstarter/ios-
oss](https://github.com/kickstarter/ios-oss)

[1] [https://github.com/kickstarter/ios-
oss/tree/master/Kickstart...](https://github.com/kickstarter/ios-
oss/tree/master/Kickstarter-iOS.playground/Pages)

[2]
[https://www.youtube.com/watch?v=A0VaIKK2ijM&feature=youtu.be...](https://www.youtube.com/watch?v=A0VaIKK2ijM&feature=youtu.be&t=26m47s)

[3] [https://talk.objc.io/episodes/S01E51-playground-driven-
devel...](https://talk.objc.io/episodes/S01E51-playground-driven-development-
at-kickstarter)

[4] [https://talk.objc.io/episodes/S01E53-test-driven-reactive-
pr...](https://talk.objc.io/episodes/S01E53-test-driven-reactive-programming)

[5] [https://github.com/apple/swift-
evolution/blob/master/proposa...](https://github.com/apple/swift-
evolution/blob/master/proposals/0195-dynamic-member-lookup.md)

[6] [https://lists.swift.org/pipermail/swift-evolution/Week-of-
Mo...](https://lists.swift.org/pipermail/swift-evolution/Week-of-
Mon-20171204/042029.html) (download the attachment)

[7]
[https://github.com/ReactiveCocoa/ReactiveSwift/tree/master/R...](https://github.com/ReactiveCocoa/ReactiveSwift/tree/master/ReactiveSwift.playground)

~~~
diggan
Thanks a lot for the comment, gives me a new view of Swift. Didn't understand
Playground was so embedded with the language and/or vice-versa. Very
interesting.

------
haskellandchill
This is very sad. I’ve been looking for something like Eve to develop
difficult user interfaces in and was hoping it would hit 1.0. Wonder if there
is any framework trying to do similar things in the JavaScript ecosystem, or
targeting that ecosystem with code generation.

~~~
RubenSandwich
Precept is almost the same model:
[https://github.com/CoNarrative/precept](https://github.com/CoNarrative/precept).
Not quite JS, but ClojureScript, which is close.

~~~
lilactown
This is really awesome! Even better, it introduced me to Clara.

------
jgale
I really admire the way that Chris and his team were open about their ideas
and their journey. They inspired me and I'm sure many others through this.
Thank you Eve.

------
dustingetz
Object Relational Impedance Mismatch Strikes Again

------
thecity2
That's a little sad. I used LightTable for a little while, and thought it was
very cool. Was looking forward to Eve, but it was beginning to seem like
vaporware, so I guess I can't say I'm surprised by this announcement.

------
divs1210
So... Will LightTable now get the love it deserves?

------
anateus
Feels like the proper place for this sort of project is HARC. Given they're
both YC, I expect that option was explored.

~~~
ibdknox
HARC no longer exists unfortunately.

~~~
Pulcinella
I thought it was still on going? It’s still listed on YCR.

~~~
iamwil
I'm also surprised at this. Did they all move over to dynamicland?

~~~
robertkrahn01
They all moved over to find the next adventure.

------
scroot
None of us really know what programming is, and we don't have institutions at
present that will allow people to explore the problem thoroughly. These guys
deserved a better culture to work in.

~~~
rntz
> we don't have institutions at present that will allow people to explore the
> problem thoroughly

What about academia?

Academia is not a great environment for creating tools that people will
actually use, which Eve was definitely trying to be; but "exploring a problem
thoroughly" is _exactly_ what academia is for.

~~~
Uehreka
Bret Victor has been writing a lot recently about why the current academia can
only churn out incremental improvements and not “fundamental research”.

The problem with both startups and academia is the need to meet constant short
term goals. Startups have limited runway and often investors who want to see a
return. In academia, most funding comes from small National Science Foundation
grants which are usually only enough to cover a fistful of months of research
and require publishing a paper with novel findings.

Many of the big breakthroughs of the mid-to-late 20th century came from long
term fundamental research that was financed either through large public
spending (ARPA, NASA) or large monolithic corporations who thought “meh,
this’ll probably benefit us in the long term and we’re pretty flush with cash”
(Xerox PARC and Bell Labs).

Unless we can find ways to fund long term research (which btw will be high-
risk, you have to be OK with getting no return for years or possibly ever) we
will not be able to tackle large fundamental problems.

------
trynewideas
Missing context: this is
[https://github.com/witheve/Eve](https://github.com/witheve/Eve), not the game
EVE Online or the Python REST framework.

~~~
masukomi
also [http://witheve.com/](http://witheve.com/) for more details on what it
is.

kinda sad :(

~~~
ModernMech
There's actually not much on the main page anymore. Try the blog for more
context: [http://incidentalcomplexity.com](http://incidentalcomplexity.com)

~~~
djsumdog
huh .. that makes me think of Squeak (a Smalltalk implementation)

~~~
seanmcdirmid
That isn't anything like morphic/lively, if that's what you are thinking
about.

------
steelmanning
This is the same man, Chris Granger, that did a Kickstarter for Light Table, a
so-called "next generation IDE," with promotional materials touting as new and
revolutionary features that had been standard in IntelliJ, Visual Studio, and
even Eclipse for years:

[http://chrononsystems.com/blog/light-table-concept-vs-
realit...](http://chrononsystems.com/blog/light-table-concept-vs-reality)

Light Table was also ultimately abandoned before completion.

Perhaps Granger should rein in his ambitions somewhat, or at least try to
delegate more (assuming there are enough people to whom he can delegate)?

~~~
ibdknox
Perhaps, but it's pretty easy to make judgements from the sideline about what
people should or shouldn't do.

I was the PM on Visual Studio. I can assure the things I showed in Light Table
weren't there. Nor were they in Eclipse, as I studied that as well. You can
pick and choose any number of things from our work over the years and say
"Hey, but this looks like that" \- I'm sure it does, but the question is does
it _work_ like that? Does it enable you the way the things we showed did?

> Light Table was also ultimately abandoned before completion.

Unfortunately even after paying ourselves only just enough to live in the area
(around 40% of what my peers were paid), we needed to find a way to eat. No
software is ever done, but we had more than 40,000 people using it and Light
Table was a stated influence on tools at Apple, Google, and Microsoft. We did
our best. Was there more to do? Of course, there always is, but at some point
we had to make the hard decision to leave LT in the hands of the community.
I'm curious what direction you think we should've gone instead?

> Perhaps Granger should rein in his ambitions somewhat

Maybe, but at the same time, we had people willing to let us try. You paid
literally nothing for access to our work, nor to the effects our research had
on others, so I'm not sure why there's this much negativity here. We _need_
people testing the fringes because where we are is so far from where we could
be. Lots of things _did_ work in Eve and there were cases where we were so
much more efficient it hardly felt like we were "programming" at all anymore.
We've shared everything we've done and we'll continue telling more people
about it in the hope that others can benefit from what we've learned.

And yet you're the one acting hurt, while I'm the one having to shutdown the
project. That's very different from the HN that rallied us to do our
kickstarter in the first place - the one that encouraged innovation and trying
to do crazy things in the off chance that they work. There's so much more to
do and I sincerely hope HN doesn't become so cynical and demeaning that it's
not worth sharing people's efforts here.

~~~
azhenley
Graduate school is a great place for "people testing the fringes."

My experimental code editor design, Patchworks [1], is one such example.

P.S. I'm a big fan of your work! Looking forward to hearing about your next
project.

[1] [http://dl.acm.org/authorize?N84177](http://dl.acm.org/authorize?N84177)

~~~
erikpukinskis
> Graduate school is a great place for "people testing the fringes."

Testing, yes, but not exploring. Grad school gives you one experiment and then
you have to start publishing. So if you have something you want to try out,
with a direct implementation strategy and a clear set of possible outcomes,
then you can do that at grad school.

If you want to try many things and iterate, grad school will not work well.
You will be expected to publish digestible “learnings”, and so you will end up
skewing your work towards ideas that are likely to produce compelling
presentations.

There’s no good place to experiment, in either the corporate or academic
world. Your best bet is to move between many domains, trying small ideas in
context while also delivering value, and only ever doing your real Hail Mary
experiments at home on your own dime.

~~~
lazyasciiart
Isn't the freedom from short term value basically the concept behind tenure?

~~~
erikpukinskis
If you don’t care if you have anyone in your lab, and you don’t have any
expenses, you’re pretty free as a tenured faculty.

But if you want students, you need to find grants for them. And if you need
materials/travel/services/etc for your research that’ll require grants too.

------
fiatjaf
Stupid idea. They had a nice platform for dealing with data, then they pivoted
into another nice platform for dealing with data, then again. But in the end
they wanted to create a visual programming language for non-tech people or
something like that. That's too much ambition.

