Quick
index
main
eev
maths
blogme
dednat4
littlelangs
PURO
(GAC2,
λ, etc)
(Chapa 1)

emacs
lua
(la)tex
fvwm
tcl
forth
icon
debian
irc
contact

EmacsConf 2013 (eev, proposal)

Links:
http://emacsconf.herokuapp.com/
http://emacsconf.herokuapp.com/proposals/59
http://permalink.gmane.org/gmane.emacs.orgmode/63646
http://lists.hugadev.com/listinfo.cgi/emacs-conf-hugadev.com
http://lists.hugadev.com/pipermail/emacs-conf-hugadev.com/

My proposal:

Title: Emacs and eev2, or:
       how to automate almost everything


To "automate a task" means to record the steps of the task in a way
that can be easily "played backed" later. This is usually done by
writing scripts - but, as we all know, there is a huge conceptual
chasm between performing a task a first time, by hand, while checking
the outputs and the docs, and writing a script to perform the same
task. That gap can be reduced, though - we can use Emacs in a way that
produces, more or less automatically, "executable logs" that are easy
enough to "play back". The tools for that are surprisingly simple, and
for several years, since I started using Emacs in 1994 to until about
1999, I would swear that Emacs had been made to be used in that way -
and I looked for other people's executable logs on the web, in vain.

An example
==========
Suppose that we have just read about a language called Foo, and it
looks interesting. Consider this somewhat typical task: "try Foo",
which can be decomposed into:

  * download the interpreter for Foo,
  * unpack it,
  * read some of its docs,
  * compile it,
  * run its examples,
  * write our first program in it ("bar.foo"),
  * run bar.foo,
  * debug bar.foo.

Let's refer to that as "task F". When we perform the task F for the
first time each one of the subtasks above becomes several steps - and
some of them, like "reading the docs", consist of opening files in
Emacs or in a browser, while some others consist of sending commands
to shells or to other interpreters. Let's introduce some terminology
to distinguish these two kinds of steps - "getting info" and "doing
things". The usual ways of scripting tasks automate only the "doing
things" - the "getting info" part is relegated to comments in English
in the documentation or in the code, plus maybe some hyperlinks.

Eev
===
Eev is a library for Emacs that implements several ways of using sexps
as hyperlinks - for replaying the "getting info" steps -, and several
ways to send commands to external programs - for replaying the "doing
things" parts -, plus some tools to let us produce those sexps and
scripts easily.

The tricky part is that these "executable logs" - "e-scripts", from
now on - are meant to be executed in a way that is quite different
from how people are used to execute normal scripts... e-scripts are to
be executed line by line, as shown in the following video:

  http://angg.twu.net/eev-videos/video4-eepitch.mp4
  http://www.youtube.com/watch?v=Lj_zKC5BR64

The main question I've been working on about this is: how can we make
this way of using the system more familiar? Perhaps by making eev2
trivial to install and by providing lots of executable examples?...

Anyway, the news - especially of more videos! - are posted here:

  http://angg.twu.net/#eev