Hi,
It's really nice to have this conversation. Long time ago I talked about
Leo and computers as "cognitive devices" for (de)construction adn how it
makes for files what Smalltalk mades for objects. But at that time I
hadn't the proper language and examples for a better discourse. Putting
this into talk with the Bret Victor's ideas and the recent developments
on IPython/Jupyter notebook or my own prototype with Grafoscopio[1] and
the new energy /routes Leo is exploring seems to create a promising time
for this conversation. More comments below.
[1] http://mutabit.com/grafoscopio/index.en.html
On 16/05/16 07:24, Edward K. Ream wrote:
On Friday, May 13, 2016 at 10:17:12 AM UTC-5, Offray Vladimir Luna
Cárdenas wrote:
In my case, when I found Squeak almost 10 years ago I felt it
interesting and empowering for me and my students, but also it
imposing to much pre-existing structure on me, while Leo with its
emerging outlining structure was a liberating experience,
particularly because most of what I do is writing plus scripting.
Then I see the improvements on IPython notebook and thought some
ideas about integrating them [3], but there was a lot of
(accidental?) complexity on the technologies behind, so I took a
new approach not with the specific technologies (Leo + IPython),
but with the ideas (outlining + live coding / interactive writing
and visualization) in Pharo[4]. In this way I'm getting the core
of what these technologies bring to me and still I'm using them
for specific purposes (Leo for deconstructing others textual code
is unbeatable).
I've been thinking about these topics.
Two days ago I installed Pharo and played with it a bit. There are a
few pluses with Pharo, especially for students. But there are also
minuses, compared with Python and Leo. For starters, Python is a much
better language for beginners, imo of course.
I thought the same for long time and in fact I taught under that
conviction. But I was making the wrong comparison. Smalltalk/Pharo
should be compared to Operative Systems (Unix and its *philosophical*
descendants: Gnu/Linux, Mac and yes, Windows). It's is a full discourse
about how interact with computers and how they should work. A long
explanation why is in [1].
[1]
https://open.library.ubc.ca/cIRcle/collections/ubctheses/831/items/1.0055157
The fact is that you don't only teach/learn python syntax, but also how
to program (paradigms, problem solving), where to program (dev tools:
IDE, debugger, source code management) and why to program ("contexts for
programming", where interactive notebooks and tools for data narratives
and visualization become important). There is a lot of moving parts and
when you're a teacher/learner the responsibility/burden on their
integration is on your shoulders. Pharo + Grafoscopio gives me all that
in a single, easy to install, update & learn integrated package with:
IDE + Live Coding + Data Visualization + Interactive documentation. The
big concession you have to do at the start is objects all the way down,
without tricks, mixtures. No functional + imperative + declarative +
objects + etc. Which for me was too big at the beginning because I lack
of the emergent free from structure given by outlining. With Grafoscopio
I'm trying to solve that.
My path was something like this:
That being said, I would like to see live coding + Leo working. And that
why next your proposal seems so interesting to me:
Later in this thread you said, "I think that interaction between Leo
and IPython shouldn't be centered around file importers/exporters, but
on "services". The question would be how to make a node of Leo become
behaves/becomes like a cell talking with IPython (with code
completion, graphics, etc.)"
I replied that this would be a lot of work. On second thought, this
"lot of work" might be an excellent new direction for Leo.
And you also said, "If I could bring one feature of Smalltalk to Leo
it would be live coding (the idea of making some Leo nodes, IPython
cells)."
I'm not sure exactly what this means, but it might be easy to do. At
present, whenever you run a script (with Ctrl-B, execute-script), Leo
creates (on purpose) a new Python namespace. It would take just one
or two lines of extra code to use a common namespace for a new
command, say execute-script-in-common-namespace, or maybe,
execute-ipython-script.
This isn't exactly IPython cells, but it would retain "live" objects
(in the common namespace).
A shared namespace to all of what is computed in Leo would be a good
start. I envision something like this namespace being talking with a
IPython kernel via ZeroMQ (BTW thanks Ken for the reference to its
author @hintjens <https://twitter.com/hintjens>). I don't know the
details but in that scenario you can have the liveness of IPython plus
emergent structure and a self-referential programmable DOM of Leo.
On my walk yesterday I had what seems like an exciting idea. I wonder
if you would be interested. It might be possible to have Leo do
everything that can now be done in Pharo. And it might not take much
additional work:
- A common namespace for certain kinds of exploratory programming.
- A graphics canvas for (student) drawing projects, and a Qt turtle
graphics library. At present, Python's turtle graphics is based on
Tk, but there is Qt-based turtle-graphics app called pynguin
<https://bitbucket.org/leeharr/pynguin>.
- Some kind of "service-based" integration with IPython. Don't know
what this would entail, but Jupyter already has a client-server
architecture, which I used while developing Leo's .ipynb import/export
commands.
- Some kind of debugging environment. The simplest would just be
Python's pdb module with Leo running in a console window. It would be
good to be able to connect Leo to a console /after/ starting Leo, but
that's a frill. It may also be possible to use parts of spyder
<https://pythonhosted.org/spyder/>to improve Leo's debugging.
- A Python tutorial, integrated into Leo by opening, say,
PythonTutorial.leo from Leo's Help menu.
- An easy way to install everything. I think Anaconda
<https://www.continuum.io/downloads>should work.
These are just my /guesses/ about what you might want for your students.
If this kind of project interests you, please let me know. I think it
would be possible to do all this for the start of your autumn semester.
This project interests /me/ because it is a new way to make Leo
popular. If we could train a generation of students to use Leo,
Python and IPython, some of those students would continue to use Leo
and would tell the world about it.
What do you think?
Advancing Leo in that direction is interesting for me also, but the
problem is that now I'm making my PhD studies and hoping to submit my
final thesis writing at the end of this year or the beginning of next
one. So I'm not giving long semester courses anymore. Just
small/intensive workshops/seminars and I have made my bet for
Pharo/Grafoscopio for my research already. Anyway, when I present
grafoscopio to more techie public, they ask me if something like that is
available in the python world and is good to be able to answer that Leo
would be exploring that path. Crosspollination of these ideas is more
important and having implementations in several technologies helps to
spread them. I have a lot in Leo documents that I could use for testing
the live coding outlining environment and we can keep sharing ideas
about this two implementations of it in Pharo and Python.
Thanks, as always.
Offray
--
You received this message because you are subscribed to the Google Groups
"leo-editor" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to leo-editor+unsubscr...@googlegroups.com.
To post to this group, send email to leo-editor@googlegroups.com.
Visit this group at https://groups.google.com/group/leo-editor.
For more options, visit https://groups.google.com/d/optout.
