

A Live Programming Experience - seanmcdirmid
http://research.microsoft.com/en-us/um/people/smcdirm/apx/index.html

======
OliverM
The experience of programming is ripe for transformation, and work like APX,
Johnathan Edwards' Subtext
([https://vimeo.com/106073134](https://vimeo.com/106073134)) (which uses the
spreadsheet UI metaphor to specify programs and expose their run time data
transformations) and, though I'm not as enthused about it, Chris Ganger &
co.'s Eve
([http://incidentalcomplexity.com/](http://incidentalcomplexity.com/)) are
making great progress towards that goal. I've been following this kind of work
for over a decade though, and it looks like it'll be a couple of years yet
before you can open up an editor the way you'd fire up emacs.

It feels like programming never really escaped its command line origins, where
all UI is orientated around ordered text transformations. Coding in that
environment is empowering once mastered, but very frustrating to master; for
me the promise of these kind of programming environments is that the same
level of mastery is possible with only a fraction of the frustration.

~~~
ibdknox
Out of curiosity, what makes you "not as enthused" about our work? The focus
on Bloom? Going more visual?

I'm really excited to see what Jonathan is doing now that he's shifted his
focus to end-user and building a releasable system at CDG. If you're
interested in this stuff, all three of us are going to be at the Future of
Programming workshop at strangeloop this year :)

~~~
OliverM
Oh, I'm still enthused about it! But I just don't have as complete a sense of
how it all fits together (presumably you're still feeling that out
yourselves). Also I wonder if it goes too far from abstraction, the ability to
name and manipulate something before specifying what it is, exactly, and how
to define something iteratively as you become more familiar with what it has
to be.

I like how the tutorial goes from concrete data, but wonder how to specify
computations where the shape of the data isn't known completely in advance, or
could change over time.

I also dislike drawing diagrams on screen when they're much quicker to sketch
out on paper, but that's probably more of a personal preference (and I've not
spent enough time with the editor yet).

I'd love to get to strangeloop but it's a long way from Dublin, Ireland! Maybe
another year...

~~~
ibdknox
> Also I wonder if it goes too far from abstraction, the ability to name and
> manipulate something before specifying what it is, exactly, and how to
> define something iteratively as you become more familiar with what it has to
> be.

We have some really interesting ideas here around query-first schema
generation. E.g. using things before they even necessarily exist as anything
formally in the system. Powerful IDEs like Visual Studio enable this workflow,
by giving you a quickfix that will create a method/function if it doesn't
exist. Coupled with heavy normalization (i.e. 6th normal form) and a nice way
of dealing with modeling in that world [1], we should be able to provide a
really nice iterative experience. Our explicit goal is for working with Eve to
feel almost conversational and exploratory. We found one of the biggest
problems with tools like Access was that they forced you to plan everything up
front, to define schemas and relationships before you can even do something of
value. That's a trap we want to make sure we avoid.

> I also dislike drawing diagrams on screen when they're much quicker to
> sketch out on paper, but that's probably more of a personal preference (and
> I've not spent enough time with the editor yet).

The current editor evolved out of the question of if we could write programs
on paper efficiently. I agree with you and one of the things I really want to
explore a bit further down the road is a sketching-like interface that enables
you to draw things directly (it wouldn't be too hard to even capture images
from a whiteboard or sheet of paper).

[1]:
[https://en.wikipedia.org/wiki/Anchor_Modeling](https://en.wikipedia.org/wiki/Anchor_Modeling)

~~~
OliverM
I'm more enthused now ;)

Sketching on paper is so much more free-form and immediate than anything I've
encountered yet in a screen-mediated interface (including apps like
Illustrator) but I'd be very keen to try new approaches. It would be
incredibly liberating if hand-drawn sketches could be parsed successfully from
a photograph.

Thanks for the pointer to anchor modeling, it's fascinating.

------
Rooki
This was an interesting read, the focus on time reminded me of the Extempore
project (see [1] and [2]).

I wonder when this article was posted? Along with the Eve announcement it
seems there's a lot to look forward to for the future of live programming.

[1] [http://extempore.moso.com.au/](http://extempore.moso.com.au/)

[2] [http://benswift.me/extempore-docs/](http://benswift.me/extempore-docs/)

~~~
seanmcdirmid
It was posted today, but written last month. It will be presented at the
Future of Programming Workshop at strange loop next month.

~~~
jonathanedwards
As will Eve!

------
VOYD
great for a bouncing ball example, not so great for enterprise level
distributed engineering.

