PHP code is nicer with iterators. This is our experience of writing PHP iterators in c++ extensions. Sometimes simplicity of visible code hide intricacies. This is the case with iterators. I will try here to put the light on the simplicity of writing iterators in PHP extensions. This is also a typical lessons learned from leveraging new possibilities due to a change. Since we are in KM this is also a experiment on using our own methology of keeping track of what is done.

Context

Our port of Kneaver on LAMP is on progress. Side to porting c++ to PHP extensions we convert ASP to PHP. There are a lot of places where we iterate on result of queries. Usually results queries are XML chunks and we do select on them. This is what it looks like in VBScript

Set Items = Channel.SelectNodes( "item")
Dim Item
For Each Item in Items
Dim TitleItem
Set TitleItem = Item.Find0("title")
Next

This is how it should be nice on PHP

$Select = $Channel->SelectNodes( "item" );
foreach( $Select as $Item) {
$TitleItem = $Item->Find0("title");
}

This is the XML fragment we use

<adress><adress2/><adress2/></adress>

Rational

We have many iterators like in our libraries. Libraries are all reachable via RSPHP a custom PHP extension ( we also have a similar extension for Python, Perl, Ruby). The object model of the semantic database and the meta process engine become brighter. Since we also embed PHP as alternative scripting engine it is important for our users that scripts are good looking. So a generic support for iterators has a good ROI. Unfortunately documentation is poor, old. So since I have a working example, actual (PHP 5.3.3, April 16th 2012) and ported I thought it can be beneficial to share it.  This is with my words, I am not an expert in PHP. Iterators are heavy duty objects, you test on 2 iterations, use it on millions, get only surprised when it fails on billions. This is why I took care in modularity and self testing code. This add a lot of lines and you should skip anything about states, precondition and postcondition at first.

My sources:

• Implementing PHP 5 OOP Extensions by Marcus Bürger
• util.c from http://somabo.de/php/ext/util/
• Simple Object Iterators in PHP By Craig Buckler
• ext/date/php_date.c in PHP source code

Iterators on PHP will be attached to a class. A call to get_iterator will be made behind the scene when using foreach. So it all starts with a class that can be iterated (there is also a concept of traversable so let’s stick to iterate). In our case this class is IRSXMLElements, a select of XML elements. Iterators can be implemented directly by the class or by a visitor lightweight class deriving from zend_object_iterator (available in Zend/zend_iterators.h).

This is the choice I prefered since it could be reused for several places. Also iterator are statefull objects, you need a place to keep the current position while IRSXMLElements are stateless. You acn imagine situations where several iterations are done simulatnously on the same object.

This is how the declaration of IRSXMLElements had to be altered to support iterators.

zend_class_entry class_entryLoc;
INIT_CLASS_ENTRY( class_entryLoc,"irsxmlelements", IRSXMLElements_functions);
IRSXMLElements_class_entry = zend_register_internal_class(&class_entryLocTSRMLS_CC);
// zend_class_implements( IRSXMLElements_class_entry TSRMLS_CC, 1, zend_ce_iterator);
IRSXMLElements_class_entry->get_iterator = irsxmlelements_get_iterator;
// IRSXMLElements_class_entry->iterator_funcs.funcs = &Myzend_object_iterator_funcs;

irsxmlelements_get_iterator will be defined below

Note that only one line is necessary, it must be placed AFTER the class_entry was sent to PHP. The two other commented lines have no effect they can be commented or not.

zend_ce_iterator is found in Zend/zend_interfaces.h

Just with this change the syntax foreach will now be accepted, subsequent errors will be internal errors.

Our code is splitted in very small procedures because some part of it is generic, some others will eventually be generated automatically and must stay limited (the class initialisation above and the get_iterator below).

The signature of this function is imposed by the framework but there are two genericity in it that can’t be exposed, hence the need of a procedure to fill the gap between the framework and the generic function.

1. In most object models iterator on class A will return elements of class B. So class B must be introduced somewhere. In our example A = IRSXMLElements, B = IRSXMLElement. B will appear as the class_entry given to RSGenericIterator.
2. Iterators (use to be channels for us) are now called Enum (Windows era). How to obtain this enum from the object is dependant on the object. Even if the name of the function Get_NewEnum was imposed by OLE Automation you couldn’t call it by a simple casting in c++, it would require templating.

zend_object_iterator *irsxmlelements_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC)
{
if (by_ref) {
zend_error(E_ERROR,"An iterator cannot be used with foreach by reference");
}
RSXMLLib::IRSXMLElementsPtr LocalObj = getObjectIRSXMLElements( object TSRMLS_CC);
return RSGenericIterator( RSXMLElement_class_entry, LocalObj->Get_NewEnum( ));
}

and this is how we create the iterator itself:

zend_object_iterator* RSGenericIterator( zend_class_entry* Class, const IEnumVARIANTPtr& Object)
{
RSEnumIt *iterator = new RSEnumIt( Class, Object);
return static_cast(iterator);
}

First thing to note here is that we will return to the framework a zend_object_iterator. This is a new beast in PHP. It is not a permanent object or a ZVAL. It is just a very lightweight object with 6 methods allocated and disposed by us. Nice.

As we use c++ the best is to derive from zend_object_iterator and add our fields. Let's first see what is in zend_object_iterator.

struct _zend_object_iterator {
void *data;
zend_object_iterator_funcs *funcs;
ulong index; /* private to fe_reset/fe_fetch opcodes */
};

funcs Will be our array of 6 functions. It is like a Virtual Method table but it’s location after data, signatures and portability dissuade us to try to code it as an interface of 6 virtual methods.

data . Seems to be used for PHP defined iterators. I suggest to set it to NULL and ignore it.

index. same as for data, just initialize and forget.

This our class derived from zend_object_iterator:

class RSEnumIt
: public zend_object_iterator
{
public:
zval* m_Current;
_variant_t m_LastFetch;
IEnumVARIANTPtr m_Object;
zend_class_entry* m_Class;
bool m_Valid;
int m_Index;
RSEnumIt( zend_class_entry* m_Class, const IEnumVARIANTPtr& m_Object);
... Code about state below should take place here
};

m_Current will hold the current value. Getting the current value could occur several times depending on the framework implementation so it is beneficial to keep it inside the iterator and simply return it (not really what we do).
m_Index will be returned as the key of the iterator. 0 is before records. We could have used -1 for end of iteration and save the boolean m_Valid.
m_Valid indicate that current position is valid. Note that iterators are supposed to be positionned on the first element after creation or after rewind.
m_Class will be used to construct m_Current
m_Object is the underlying c++ object supporting the iteration. It is not the object we started from, this one is already the iteration on progress.
m_LastFetch is the last internal object available for getcurrent but not already built as a PHP object. m_LasFetch could have been saved at the cost of moving the code inside getcurrent into moveforward.

if m_Valid is false m_LastFetch and m_Current should be empty.
if m_Valid is true and m_Current is not empty it must be the PHP representation of m_lastFetch.

Hum, I should remember Betrand Meyer lessons better, let’s reread it first and explain correctly.

States of the iterator:

You can skip this paragraph on first reading.
#ifdef _DEBUG
enum RSEnumItStates
{
RSEnumItJustCreated = 1,
RSEnumItValid = 2,
RSEnumItAfterEnd = 3,
RSEnumItCurrentSet = 4,
RSEnumItBeforeFirst = 5,
};
#endif

1. Before first fetch
2. After Successuful Next, or Valid Position
3. After End
4. Valid with Current created

#ifdef _DEBUG
// States are here to verify the code potientially by
// testing more than necessary for it's logic, hence ifdefs
bool m_JustCreated;
RSEnumItStates GetState()
{
if ( m_Valid)
if (m_Current)
return RSEnumItCurrentSet;
else
return RSEnumItValid;
else
if ( m_JustCreated)
return RSEnumItJustCreated;
else
if (m_Index == 0)
return RSEnumItBeforeFirst;
else
return RSEnumItAfterEnd;
}
#endif

Rewind: Entry Any state, Output 2 or 3

Current: Entry 2 or 4, Ouput 4

Key: Entry 2 or 4, Output same

Next: Entry 2 or 4

HasMore: Entry 2, 3, 4, Output same

invalidate_current: Entry

dtor: Any

Here is the list of calls for the sample

get_iterator
- constructor
rewind
- move
-- invalidate
hasmore
currentdata (once per loop, not depending on how many times you use the variable)
currentkey (if key was used in foreach)
move
- invalidate
hasmore
current
currentkey (if key was used)
move
- invalidate
hasmore
dtor

So rewind is called before anything, hasmore before entering the loop, moveforward at the end of the loop. hasmore really tests that current is valid.

The constructor of the iterator:

RSEnumIt::RSEnumIt(zend_class_entry* Class, const IEnumVARIANTPtr& Object)
{
// inherited fields
data = NULL;
index = 0;
funcs = &Myzend_object_iterator_funcs;
// declared
m_Valid = false;
m_Index = 0;
m_Class = Class;
m_Object = Object;
m_Current = NULL;
}

As expect data and index set to 0. funcs initialized with the data below, and the iterator is build in state “before first fetch”, a state requested by PHP and that will be changed by an initial rewind.

Next and to introduce the 6 methods this is a static object constructing the table of ethods and used above in the constructor

zend_object_iterator_funcs Myzend_object_iterator_funcs = {
RSEnumIt_dtor,
RSEnumIt_has_more,
RSEnumIt_current_data,
RSEnumIt_current_key,
RSEnumIt_move_forward,
RSEnumIt_rewind,
RSEnumIt_invalidate_current
};

each functions


void RSEnumIt_invalidate_current(zend_object_iterator *iter TSRMLS_DC)
{
RSEnumIt *iterator = static_cast(iter);
invariant( (iterator->GetState() == RSEnumItBeforeFirst) || (iterator->GetState() == RSEnumItValid) || (iterator->GetState() == RSEnumItCurrentSet));

if (iterator->m_Current) {
invariant( iterator->GetState() == RSEnumItCurrentSet);
zval_ptr_dtor(&iterator->m_Current);
iterator->m_Current = NULL;
}
invariant( (iterator->GetState() == RSEnumItBeforeFirst) || (iterator->GetState() == RSEnumItValid));
}

aaa

void RSEnumIt_dtor(zend_object_iterator *iter TSRMLS_DC)
{
RSEnumIt *iterator = static_cast(iter);
if (iterator->m_Valid)
RSEnumIt_invalidate_current(iter TSRMLS_CC);
// destructor called by delete will clear m_LastFetch and m_Object;
delete iterator;
}

aa

int RSEnumIt_has_more(zend_object_iterator *iter TSRMLS_DC)
{
RSEnumIt *iterator = static_cast(iter);
invariant( (iterator->GetState() == RSEnumItAfterEnd) || (iterator->GetState() == RSEnumItValid) || (iterator->GetState() == RSEnumItCurrentSet));
return iterator->m_Valid ? SUCCESS : FAILURE;
}

zzz


void RSEnumIt_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC)
{
RSEnumIt *iterator = static_cast(iter);
precondition( (iterator->GetState() == RSEnumItValid) || (iterator->GetState() == RSEnumItCurrentSet));

if (!iterator->m_Current)
{
// We create m_Current only on need
if (iterator->m_Valid)
{
MAKE_STD_ZVAL(iterator->m_Current);
RSMakeObjectGeneric( iterator->m_Current, iterator->m_LastFetch, iterator->m_Class );
// This would be for an iterator returning strings
// ZVAL_STRING(iterator->m_Current, "test", 1);
}
else
{
// this is a macro, braces around are needed !
ALLOC_INIT_ZVAL(iterator->m_Current);
}
}
*data = &iterator->m_Current;
postcondition( (iterator->GetState() == RSEnumItCurrentSet));
}

aaa

int RSEnumIt_current_key(zend_object_iterator *iter, char **str_key, uint *str_key_len, ulong *int_key TSRMLS_DC)
{
RSEnumIt *iterator = static_cast(iter);
precondition( (iterator->GetState() == RSEnumItValid) || (iterator->GetState() == RSEnumItCurrentSet));

*int_key = iterator->m_Index;
postcondition( (iterator->GetState() == RSEnumItValid) || (iterator->GetState() == RSEnumItCurrentSet));
return HASH_KEY_IS_LONG;
}

aaa


void RSEnumIt_move_forward(zend_object_iterator *iter TSRMLS_DC)
{
RSEnumIt_invalidate_current(iter TSRMLS_CC);
RSEnumIt *iterator = static_cast(iter);
precondition( (iterator->GetState() == RSEnumItBeforeFirst) || (iterator->GetState() == RSEnumItValid) || (iterator->GetState() == RSEnumItCurrentSet));

// we increase Index is all cases, means this is also now the index that current would have if valid
iterator->m_Index++;
precondition( (iterator->GetState() == RSEnumItValid) || (iterator->GetState() == RSEnumItAfterEnd));
}

aaa


void RSEnumIt_rewind(zend_object_iterator *iter TSRMLS_DC)
{
RSEnumIt *iterator = static_cast(iter);
postcondition( true);
#ifdef _DEBUG
iterator->m_JustCreated = false;
#endif
iterator->m_Index = 0;
RSCheck( iterator->m_Object->Reset());
RSEnumIt_move_forward( iter TSRMLS_CC);
postcondition( (iterator->GetState() == RSEnumItValid) || (iterator->GetState() == RSEnumItAfterEnd));
}


Several Kneaver software products are now available via RSPHP our generic PHP extension. All API are object oriented.

Among the differences between c++ and php the order of destructors. Say you have

    $DB = new RSDBConnection;
    $DB->Open( $DSNName);
    $Cmd = $DB->MakeCmd( $SQLRequest);
    $Rec = $DB->Query( $Cmd);

$DB will be destroyed first, $Cmd after and then $Rec

while in c++ it would be just the opposite. So you have to make sure there are not issues hidden behind dismounting stuff in the wrong order.

Since KNVHTML can now be used directly from a php script comes the problem of performance. Instead of having an object allocated once for all in a session it is created on every page. It took 1 sec before. That was too long.

I reviewed some discussions about optimizing wordpress before: http://www.arnebrachhold.de/2007/02/16/four-plus-one-ways-to-speed-up-the-performance-of-wordpress-with-caching/, and here http://www.prelovac.com/vladimir/optimize-wordpress-page-loading-time-with-php-speedy-and-wp-super-cache.

• A few template compilation are now done on demand. This saved 20% of time.
• Instead of scanning and loading templates from html text files scattered in directories we build a cache file. It is fully transparent, the cache is rebuild automatically whenever a template is changed.
• The cache will save XML data as binary. Saving as binary saves a lot of text processing. So this of a new feature of RSXML and our Btrees: binary save. A side benefit. It will also be used in RPC marshalling between clients and KNVSrv servers adding also performance there.

Google will stop updating Google Desktop. See http://googledesktop.blogspot.com/ . I will miss it because I could see several advantage to this solution. It could index many types of files, it was possible to do a search on both Internet and you disk. Like this in one blink it is possible to see if anything new on the Interne could be more helpful than a past information, or the opposite avoid to search again something that was already validated.
Now replacement for Google Desktop. Not much I am not willing to use Microsoft Search. It is slow, returns bulk of data, it will not search many file types.
So use Kneaver ? Well Kneaver as a search engine itself and the aggregator offers interesting capabilities.

Listening to Frank Zappa, Joe’s Garage. Suddenly the succession of terms Knowledge, Information, Wisdom catch my attention. I was concentrating on debugging so I though it was an illusion. No it’s correct. Very early mention of DIKW in About DIKW (http://en.wikipedia.org/wiki/DIKW) in Franck Zappa

Packard Goose, Joe’s Garage Acts 1-3

Listen to Mary’s (Girl in the bus) vision at 2.56 or read at http://frankzappa.lyrics.info/packardgoose.html

Now I know why this was so familar to me. I surely heard it many times, years before starting Kneaver.

Tonight is my first tentative to run Kneaver directly with MySQL as database engine, and PHP as the script front end. This is the first step before being able to use Kneaver directly, inproc from WordPress.
What started as an idea late this afternoon is not taking shape. Just switching from a very simple VBScript file to it’s equivalent in PHP 5, changing the connection string. This took 10 minutes and already here it goes: It Works !

This is really a benefit of having a long experience in porting software and making it modular from start. It works in 10 minutes just by a few lines added, a recompilation of one or two dlls and we have native integration to MySQL and PHP. No ODBC, COM involved. I try to compile it and run it on Linux tomorrow first thing.

This will not be the final setup because running Kneaver inproc is not going to be very efficient. Just after the next step is to use the object broker and run it as a service like a database. Connections will be persistent and the cache mechanisme build into it will make it very efficient to use it as a WordPress Addin.

In my search of productivity I am looking for solutions to help me stayed focused and keep track of how much time is dedicated to most important objectives. I describe here my requirements and me experiences.

It is a recurring question and I learned that there are no perfect solutions. Being my own boss and with so many aspects I can’t do just with timing my time at work or consider time spent on tiwtter as a pure loss. Even while walking in the countryside my mind keep working on issues and it is very common that ideas pop out my mind on the return faster than it would have staying in front my computer trying to evade the tentation to check news. What is the most productive time ?

For example I regularly remove from my desk applications like rss reader ( I use sharpreader), tweetdeck or even MS Outlook. So today I started Tweetdeck again and lurked to what other says.  Suddently i am attracted by a tweet from @crid :

Instant Boss. Ce petit soft gratuit qui ne ressemble à rien est encore en train de sauver ma journée de travail http://appsapps.info/instantboss.php

My translation: Little software not great looking is saving my day.

Good I like this, let’s try. So I went, I tried, I write.

The really good thing is that it’s not taking space or too much attention. Small footprints. It starts from a postulate that you split your day in regular period of attention and distraction. Fair enough but nothing so regular. I tried for a few hours and realized it would be complex to tune it really to my rythm.

Distraction is part of human nature and I explained before it may end up in saving time. What is important is to keep it under some limits. See The Attention Span Myth.  

That reminds me of a very simple tool I used for years and trained several people to use including my kids. Le minuteur (The timer) : this one is my favorite. I even bought a couple of them to bring them with me to our South India subsidiary. http://www.tati.fr/cuisine-ustensiles/la-preparation/balance-minuteur-doseur/minuteur-de-cuisine/35273.html . Costs 3 € = USD 4.

When planning tasks and specially at the level of a day it is important to have an objective idea of real time span for them. So using a timer next to you whatever you are doing (and this is a big benefit on software) you can estimate and measure. Say how long it takes to read the subject of your essay for an exam : 5 minutes, or 15 ? Wind up completely the timer and start. When you are finished see how long it takes.

Now that we gathered a typical duration for a set of tasks our estimation is really better. Instead of packing the day and being deceived by how little we can do we are more realistic.

So my typical time control software should have a learning mode based on a set of 100 typical tasks I do. One of them would “write a blog entry”, takes 2 hours. When I start the software i wish to say what I want to do today and it fetches automatically time estimates. It will then may be tell me if I am distracting or forgot to tell when i am done. Since there is a learning stage I could also tell which tools I will typically use and may be automatically hide those distracting me.

Las time I used a time control solution it was TimeRescue. This is a much more ambitious thing. I used it as an experiment after another blogger wrote about it. May be here http://blog.ernestsemerda.com/2010/04/03/3-great-tools-fine-tune-productivity/ . With Kneaver I am really interested in all experiments about using computers to achieve our goals. Still I am not for Total Recall type of things. See here http://guido.appenzeller.net/wordpress/ . So RescueTime was ending up considering that using Internet Explorer while debugging code was a distraction. You have to tune it but here you get into the issue when you have different type of activities. You would need to have a profile for each and what about multitasking. Very often we will have a window on a long job and another to check our mail. Too automated, to systematic, not enough understanding of my goals, my purpose. 

I had the same problem with Xobni for example. Not being able to make a difference with private sphere and professionnal is leading to absurdities. When I click on a mail sent by me I would expect the recipient to be displayed, not me. Again the issue is that all these software don’t know me, they have no background and are just piece of code leveraging a single idea. hence the need to have somewhere a set of informations on our basic commitments, our interests.

Before writing this I checked what other tools are on the market. I found TimeDoctor.

It strickes me that time control and boss/employee relationships are so often concomittent. In the case of TimeDoctor it is definitely engaged in this niche fine but Instant Boss is for a single user. So at some stage I need to behave as if I was my own boss delegating to my computer the role of controlling me.

I didn’t try TimeDoctor but by reading the web site I felt it was not made for my case. TimeDoctor is more to monitor employees work and keep track of how much time is spent on target or not. I like the idea of definition targets first and not preventing distractions.

If you got his way be careful that in some countries legislation may prevent you to spy your employees. Say if the screen shot shows private data you violated their privacy and this is even more risky. I think this idea is leading to microcontrol and ending to loose more time reviewing how the others spend their time then what working in a team is really about : delegating and allowing you to do your own job. Controlling others time is really leading us 100 years back to Theory X style of management.

If you are interested in time management and can read french I recommend [Time Coach]. It’s a combined mail based learning program with personalized interaction followed by a newsletter. And it’s free. I wishes a time management control starts with some of the ideas found here.

So end of the day ? I couldn’t find the perfect solution. I wish I can find something that assist me in some occasions, helps me keep track of some activities as discreetly as possible, linked to my tasks management and daily planning. Ability to relate tasks to objectives and goals, ability to label them as important and urgent, repeating. It will preferably use Kneaver API to gain knowledge of what I do and what it is related to. I am afraid I got one more item on my todo list.

I was so unhappy with outlook management of recurrent tasks I wrote a new scheduler I called KNVPlanner. 

Several routines must be restarted every now and then. The more you become precise and add tasks, the more specific you become, the most impossible it is to deal with them all. Let say that if at any time you reached some balance between busy and free time as soon as you add one more you are done. The only solution is to re-plan completely by allowing relaxing some routines. Also if we miss too often a schedule and don’t measure any possible impact it means as well that the task can be rescheduled with no arm. My ultime goal was to make sure that routines are done while keeping as much as possible free time and flexibility. So what I needed really was a de-scheduler.

Due to limited time I didn’t reuse outlook tasks records. I could have Kneaver toolbox has all capability to do it. I just started a plain new database and a little coding for a planner object and a web page to display the list of tasks and mark them as completed.

Outside from periodicity adjustments I added extra features like :

• Collecting actual frequencies and durations and suggesting reasonable schedule based on measures.
• Ordering tasks by duration on a given period. Very often we look for a small task to fit in a time hole. Waiting for a phone call in 10 minutes what can I do in 5 minutes.
• I distinguish tasks totally manual requiring focused attention for the duration (like wiring a blog post) from tasks that will require waiting periods (like a backup for example).
• Tasks are chunked as much as possible so that they can be placed in small slots and imply no waiting periods.
• Some tasks are a really long task made piece by piece like reviewing a customer database. This means you must have a an extra information to track what is already done. Other tasks implies a counter (send 3 proposal per week) so it is not only period but also a count of action you want to measure over time.
• Benefit of using a web based component is that it will naturally live accros multiple device and OS.

I am finished with this small program and will try it for a while. I am very interested to see the impact of being able to deconstruct a plan. I have been hesitating to do this program a long time because I thought that personnal planing was too off track from PKM. Maybe I was wrong.

My Cat Scanning the View

The title looks like a potpourri. It’s normal.

When my cat is allowed to go out in the morning, the first thing it does is to scan the neighbourhoods from the terrace. It stands on a small pillar and turns its head, slowly and zooms on the propitious spots. Mouse, lizards, cats are on the radar. Trees and high grass are hiding them. It takes 30 seconds and here it goes. It jumps into the garden to get a close eye on something.

I have about the same attitude when I check my mail or the RSS aggregator in the morning, a mug of coffee in my hand, looking to cat on the terrace.

The first thing that pops to my eyes and tries to capture my attention is spam. Obviously those behind this plague know that orders, banks, credit cards are high on our agenda. For this reason scanning the Inbox is usually very deceptive and useless. So the very first task is to run the spam filter(s). What the spam filter does (after obvious steps) is to take a suspicious look into the contents, scanning for outrageous hints. Any deceiving term would flag it as spam. Scarcity of terms in our field of business and abundance of engaging term (free, money) are impacting as well. The point is that scanning to remove spam is similar but different in the fact that we look for exaggerated proliferation or out of subject terms instead of informative messages.

It becomes more and more the same with RSS. RSS are not cluttered by spam but with 3 million and counting bloggers it is over abundant. Twitter started a new era and we get now from our friendfeed a continuous flow of messages about all and everything. I was not going to spend time looking for a pearl in this sea.

We have a nice tool in Kneaver which takes a text and evaluates it against our personal knowledge. Basically a natural language parser will take it, identify terms available in the corpus, compute their frequency. Up to here pretty common. Now what is less common is that we compute some sort of distance between the terms in the text but also in the corpus. For this we use graph distances and semantic vectors. What we are really looking at are texts mostly residing in our Knowledge Frontier. They are the most likely to bring us something new but still in the focus. This is really similar to the cat approach. Is this grey color likely to be a cat, if yes I should see another hint nearby: something moving or another grey patch.

Now we are testing an RSS valuator filter base on this feature. What you get is exactly the original feed but some styles are added so that your RSS newsreader will display it in colors depending on the foreseen interest. It is now easy for the relax reader to spot the most interesting news. Nice feature and very personal.

However what you will not get are the hidden pearls. The interesting piece of news, totally out of context, lost in the stream of professionally oriented streams. To illustrate this when I reviewed my daily delivery of news from Guy Kawasaki (I follow him for informations and hints in the perspective of his books) , filtered by Kneaaver, I could see, lost like a bottle in ocean, a piece about Chris Ware. I like his work and so do my son but this piece was completely outside of my job interest. Kneaver couldn’t catch it, I could. We, human, remain better than software. We can adapt at once any procedure and incorporate extraneous exceptions on the fly. Yes but without Kneaver raising the visibility of interesting pieces, I wouldn’t have the spare time to look for an out of band piece.

Wow! the cat was stung by a wasp while I was writing. She’s young and need also to enhance her scanning procedure.

Location: http://eric-blue.com/

I came across this blog while looking for combined use of Wiki and MindMaps. Kneaver combines naturally both as being alternative displays of the same body of Knowledge. Presentations is yet another.

Back to Eric Blue. Eric had a post about visual Wiki. This is the link: http://eric-blue.com/2009/05/12/the-visual-wiki-a-new-metaphor-for-knowledge-access-and-management/. It was conference from John Hosking  (http://www.cs.auckland.ac.nz/~john) about Visual Wiki. IMO the video is a not very conclusive. May be the most interesting is the mention of thinkbase (see it directly at http://thinkbase.cs.auckland.ac.nz/)

Eric has a goal of building his own Personal Memex from open source components. I fully agree with him on the necessity of graphical capabilities. Alas Kneaver is not open source so I can’t help otherwise Eric would be able to continue his mindmap directly on Kneaver

 Back on the question of open source and how much technology can be projected client side. This is a very complex issue since most path leads to dead ends.

• Anything based on Flash uses a proprietary software not uniformly supported (iPhone). Howver his mind map is running with Flash and freemind browser and it works.
• Anything on java is likely to causes issues as well. Either browser not running java or performance. Thinkbase on top of java is hard to start (even with Chrome). We experienced this also in another project. The graphic was neat, interactive and all but most visitors just didn’t see that an applet was present
• HTML5 canevas has also a caveat: Internet Explorer don’t support it and still it is 70% of the market.
• SVG had limited support via a plugins supported by Adobe. Adobe don’t support it anymore (normal in between they have flash and there are svg viewers based on Flash). 
• No client technology. Just plain jpeg files.

Today we support SVG, jpeg (server side computed, will work everywhere including cell phones) and mm (can be visualized with Freemind viewer). Youcan swicth from one technology to another.

The truth is there are plenty of software for mind mapping (http://www.mind-mapping.org/full-list.php) but a lack of standardization. Most of them operates like powerpoint. You work on a single map at a time and end up wondering where is the best place to store your notes. This is one of the barriers we break. Maps are only a view among others of your thoughts.

Now what is the most exiting part of his blog is the Personal Memex. Taking the idea from Vannevar Bush and to start pick and add building blocks as they appear on the market. That’s very inspirational. http://eric-blue.com/my-projects/personal-memex/

It’s like a shopping list, we are waiting to see what the cook prepared with the ingredients.

• Core – Mediawiki (Content Management System, Wiki)
• Document Management
• MindMap
• Semantic capability
• Search
• Bookmark
• webpage capture
• Timeline browsing, faceted browsing
• Multimedia integration

You can also see the requirements

• Capability to act as a “bit-bucket”. That’s really our KneaverTray and the Kneaver pipeline or Knowledge hose.
• Ability to store “Notes”. Ok again.
• Timeline access. goes back to facet browsing and mental frames.
• Navigation beyond traditional hierarchy. for me it is the same as above.
• Comprehensive search
• Ability to store meta-data. I would add meta-linking.
• Ability to import, export and share. I would share as much as possible or import and subscribe to stay current.
• Integration with mind maps. I would add Powerpoints, texts, databases.

What is missing IMO:

• Automated discovery system that will connect things together. My input is a text, a mindmap, a document but I want the system to automatically understand where it stands.
• Continuation prompts: inductors are a generalization of pending wikilinks. This is a cumulative knowledge database and I want to be able to continue from any pending links, find them and kneave them together.
• I need to be able to turn seamlessly some part of existing knowledge into meta data. For a recipe I need the ingredients, the time it takes for preparation and then a body of text or a video. Now go back to every recipe and check this is available.

Eric Blue’s blog is very active. Since 2004 several posts per month. Real good work and plenty of interesting contents. I wish I have the occasion to return to read it often.