Thanks Evan for the detailed info. This is a busy week for me, but next
weekend I will be giving a more detailed look at your software and
answering your mail.
Cheers,
Offray
Ps: for some reason your post don't become part of the thread in my
mailing client. They start like new post, but keeping the title. :-/
On 27/07/15 18:44, Evan Donahue wrote:
Ah, yes, by 'offline' I did mean outside of the mailing list, but that
was purely out of consideration for the list. If the list wants to
hear it, far be it from me to keep it from them.
For my part, I am a graduate student working on my dissertation, and I
have been trying to build tools to facilitate that as I go, from
taking and sharing notes, to visualizing primary material, to
(eventually) organizing and writing the dissertation. I have been
following Offray's updates with interest, as I think my goals are very
much allied, but I am starting in a slightly different place, if I
have understood correctly (research and organizing, and not yet
writing, sharing, or publishing). My efforts thus far have been
concentrated in two repositories:
Chancery (http://smalltalkhub.com/#!/~EvanDonahue/Chancery
<http://smalltalkhub.com/#%21/%7EEvanDonahue/Chancery>) is an early
prototype for a note taking system. I am coming from taking notes in
emacs org-mode, and so Chancery right now is the most straightforward
collapsable tree outliner/note taker that could give me functionality
basically equivalent to what I had in org-mode, and serve as a
platform to co-evolve my research methods and their supporting
technology. The near-term goals for this involve adding metadata
(authors, dates, etc) to the sources I am annotating and using that
for various kinds of historical visualization (and further, attendant
annotation) eg who wrote what when, referencing who, influenced by
what, etc), and can I edit all that directly in its graphical form.
The status of this project is that it is usable by myself and those I
have worked with on it (and I use it as my primary note taking
system), but I'm not sure what it would look like to someone loading
it at the moment (no real intro/docs, as it was just a quick prototype
to provoke further design discussion).
Trantor (http://smalltalkhub.com/#!/~EvanDonahue/Trantor
<http://smalltalkhub.com/#%21/%7EEvanDonahue/Trantor>) is a
disttributed p2p system for incrementally keeping data structures in
sync between multiple, asynchronously connected pharo instances across
the internet without requiring human attention to resolve merge
conflicts (think laptos where data is edited offline and then
automatically synced when they connect to one another); it is my
answer to sharing and collaboration for things created in Chancery
(although it is a more general purpose project). Functionally, Trantor
provides a set of common datatypes (set, dict, text blob, etc) and a
means to run nodes and peer them for synchronization of said
datatypes. The goal with respect to Chancery/personal information
management is being able to easily grab some structured set of notes
or writing out of the note taking system and share it with
collaborators or colleagues with a button click, and without having to
go through the whole export/send/manage versions dance. This project
is about 85% complete, the proof of concept works, it just needs a big
refactor to make it usable and quash some bugs.
I guess my observations on using Pharo thus far are first, that it is
absolutely ideal for evolving prototypes, since you get a sort of poor
man's gui and persistance (object inspector + image serialization)
basically for free, which is 90% of the work of such a simple
information management app prototype. I have a fully functional tree
outliner at a point when in another language I would still be trying
to hack a low functionality command line interface. The other thing
I've found refreshing is that my application can live as one among
many within the image, sharing data with other programs by passing
objects around in a way that is impossible to do with a standalone
application running on a modern operating system. the dream of the web
is, I think, heading more in this direction, but working with the
browser (as I was before I came to pharo) requires coordinating a
separate server process, compressing everything into http/html/json,
and a host of other problems that vanish when you can just serialize
objects between pharo instances. In short, I'm getting a lot done in
this language and I expect I'll be around for a while.
Cheers,
Evan
