David Pratten

Announcing (On One Page)
(On One Page) – is an information design pattern aimed at assisting people to master best practice guidelines, policies, procedures and bodies of knowledge.  I have created some examples:

1. New South Wales Health Department’s, Aged Care Assessment Guidelines (On One Page) .  This is sourced from a 144 page book!
2. The Project Management Institutes’s, PMBOK Guide – Fourth Edition (On One Page). This is a 350+ page book.

Principles
The (On One Page) design pattern has the following features:

1. The user is presented with a one-page visual metaphor of all the concepts contained in the book, manual or “body of knowledge”. In the case of a book the index may be an adequate visual metaphor.
2. The one-page visual metaphor:
   • is interactive
   • gives each concept a fixed position in relation to all other concepts
   • allows focus by only showing a subset of all the concepts at one time
3. The concept in focus is gold coloured and “see also” concepts are colored light blue.
4. For concepts with associated text, the text may be displayed in a popup window.

By means of these design decisions, users may

1. See “both the wood and the trees” simultaneously. The wood is the whole body of knowledge and the trees are individual concepts.
2. See the interconnections between concepts.
3. Use spacial as well as verbal memory to master concepts and their interrelationships.

Opera has just released Opera Unite web server in the browser technology. Here is analysis by Mashable. Opera Unite is an enabling technology for tier agnostic Request Based Distributed Computing (RBDC). Key issues directly addressed by Opera Unite include:

Drivers

• Build Distributed Applications
• Provide programmers with a unified programming model (i.e. not deal with a separate programming model on the client)
• Build Mult-tier applications
• Use existing technologies
• Enable applications to ‘run anywhere’
• Provide a Language agnostic mechanism
• Use a Client agnostic approach

Conclusion
Reading the Opera Unite announcement has confirmed that the building blocks of RDBC are coming into being.

Here is the Ambi code to calculate the Collatz sequence including a demonstration for the largish number
99,999,999.  To run this code simply copy and paste it into the wholly browser based Ambi implementation.


// Collatz Sequence Function;
function; collatz ;
 if;
  import dup $n = 1 neq;
  ifelse;
   $n 2 / floor $n 2 / dup $half = eq;
   $half . collatz export;
   $n 3 * 1 + . collatz export;
   ;
  ;
// Show sequence for a big number ;
99999999 collatz

After TABing or Clicking into the Result box, you should see the 169 term Collatz Sequence for this number (which I won’t bore you with here).

Django has won me over. But it can be improved!

Delivering web applications using django is a sublime experience – its core ‘do not repeat yourself’ philosophy and the built in admin application makes development of applications easy and fun.

There remains however a major source of “repeating yourself” with django. The schema in the database is separate from the application definition in .py files.  This separation can currently be addressed in two ways neither of which are entirely satisfactory.

1. The django admin inspectdb utility will create a basic application definition from an existing database.
2. The django admin syncdb utility will create tables in a database from a django application definition.

However, neither of these utilities solve the problem of keeping a database and an application synchronised under incremental change.

This situation could be improved by defining the application as a meta-data annotation of the database.
If the application is an annotation of the database then irrespective of how the database structure is changed, the application will be simultaneously updated and vice-versa.
Notes on a candidate solution
A core issue is making 1-1 correspondence links between tables and columns in the database and django application annotations. These links need to survive arbitrary sequences of ALTER statements, and disappear after DROP statements.  In mySQL, one way of doing this would be to store a GUID in the table and column comment fields in the database information_schema.  The comment field survives ALTER statements and will disappear after DROP statements.

With these GUID’s in place, all the django specific annotations (e.g. verbose_name=”") may be stored in an a per-application definition table and the django models.py, admin.py files may be regenerated at any time based on introspection of the database information_schema + this applications annotations.

If you (like me) find chasing down references for academic assignments to be a challenge then you may be interested in this. My use-case is the exploring stage where you would like to save a reference then search Scholar for that author and/or search on the title of the article.

I have just enabled Refworks references to link back to Google Scholar search. Google Scholar (which links neatly to your university’s library) naturally pairs with Refworks (I am currently on a 30-day free trial of this magic service for accumulating references from Scholar) But vanilla Refworks is a deadend. But help is at hand — now you use a greasemonkey script (greasemonkey is a plug-in for Firefox browser) to link back to Scholar search!

The script is called “Refworks link to Google Scholar” and it makes Refworks.com link back to Scholar! As shown here …

Without the script enabled, the Refworks view normally shows like this …

Enjoy!

This script just scratches the surface of what is possible!

I have been writing a paper on internal marketing and marketing orientation and hitting Google Scholar and a trial subscription to Refworks pretty hard.

I have a few of use-cases that I would like to see better support for.

1) Given a search term which are the foundational break-through papers that initially defined the concept and defined the “ground” of the concept.
2) For a search term, which are the key papers that stand within the tradition established by the foundational papers that have developed the ideas in the last 5 years. This could be translated into the query: “For a search term’s group of most cited N (therefore foundational) authors find all papers in the last Y years that cite M or more of them.”

Ambi is proving to be a great extensible RPN calculator. Applying the ‘zen’ of RPN to programming fun!

Enjoy the new release of Ambi.

This week I have discovered that the seq operator is not necessary.  Initially, I thought that seq would be necessary, however it turns out that the other lambda operators are sufficient.  So we now can write an interative approximator of cuberoot in this way …

function; root3;
  dowhile;
    import dup $n = $guess =;
    $guess $prev = $n $prev sq / $prev + .5 * $guess =;
    $guess $prev - abs .000000001 >;
    $guess export ;
125 root3 .


Not a seq in sight!   And we may rewrite the function as a recursive function this way …

function; inner-root3;
 if;
  import $n = import $prev = $prev $n $prev sq / + .5 * $guess = $guess $prev - abs .000000001 >;
  $guess $n inner-root3 $guess =;
  $guess export;

function; root3;
  import dup inner-root3 export ;

100 root3 .

In addition the current release adds the ++ and – increment and decrement operators.