Cursory progress log/report
Jake Smith
In-line web page editor
Fri, July 15 2011

As a preamble, this report is late to be generated.  While I 
cannot say it did not cross my mind, my uncertainty as to what 
to include and desire to begin exploring the technology were 
enough to prevent my pursuance of writing until now prompted.

For much of the first few days of the project, namely July 5th 
through the 8th (my first Tuesday through Friday), much of my 
effort was spent towards simply gaining some semblance of
understanding of HTML, CSS, and javascript.  Throgh this 
process, I initially created a few simple webpages, 
experimented with the content and styling in a very simple 
manner, just using online references (namely, W3schools.com) as 
a guide and a text editor (linux gedit, for want of a better 
tool).  By the second day, I had begun using the Firebug plugin 
for Firefox as an aid, visually linking content with ideas, 
which I did find somewhat helpful.  I quickly moved on to 
attempting to include some form of javascript into my pages,
which I met with relative success.  While not particularly 
powerful scripts, I managed to include some and gain an 
understanding for that as well.

Through the second week, I delved more into the material of the 
project, proper.  My initial task was (and remains) the issue 
of introducing a live 'cursor' on the webpage.  I spent a lot 
of time the first couple days pouring over the DOM panel of 
Firebug, trying to gain a deeper understanding of the DOM, and 
how the javascript I was wiriting interacted with it.

I also looked into JQuery relatively early this week.  While 
obviously powerful and stable across platforms, its usefulness, 
I have concluded more through attempted use than reference, is 
limited in this project.  Jquery simply tends to operate at 
a level of abstraction that is too far from the material to 
be truly useful in many ways.  By way of analogy, it is akin to folding origami while wearing three pairs of mittens.  That 
said, JQuery has proven useful as a tool on the side, allowing 
for the easier building of tests and helper methods; for which, 
having a rather straightforward and accessible (albeit 
limiting in some ways) API was very welcome.

As I have delved more deeply into the issue of cursor insertion 
this week, I have run very solidly against the limited 
debugging options of javascript, as well as the innate problem 
of the 'sloppiness' of the language with a good IDE or 
equivalent for ease of legibility.  It seems that, in addition 
to writing functioning code, I have to expend a lot of effort 
to keep that code from rapidly warping into a tangled morass 
of muddled program logic.  This is especially when trying to 
make for some kind of debugging and when scaling older code 
to accomplish something new.  (okay, not meaning to rant about 
the language; I'll stop).

With these limitations of the language (javascript) itself on 
top of having to learn many, very low-level and detailed 
aspects of web pages and the mechanisms that operate on them, 
progress on just a single feature-- cursor insertion from a 
mouse click-- has been excruciatingly slow.

What I have managed to accomplish is to insert and remove a 
unique <span> tag to mark a cursor.  This is separate as a 
small 'module' of javascript, and does (from what I can tell) 
almost exactly what it should.  It preoccupies itself only with 
the insertion and removal of a cursor, and takes an 'index' 
(the location within an element of text on the page) and puts
the cursor around that.

The aspect that has absorbed the better part of three days has 
been the other side of the issue: translating a user click to 
a position that can (directly or indirectly) be used by the 
aforementioned method or one descended from it.  Conceptually, 
its behavior is in place, but translating that idea into 
functioning behavior has been a slow thing coming, and has yet 
to be truly acheived.

***abandoning prose; some things looked into: 
DOM Range objects, native element addition/removal of 
child nodes, limitations of JQuery, cross-browser concerns, 
keeping textNode elements as such-- leave string processing 
out of the javascript as much as possible