It is common in various web frameworks to pass pretty much everything through a central script using Apache .htaccess file and mod_rewrite.  For example enabling permalinks in a WordPress blog generates an .htaccess file like this:

RewriteEngine On
RewriteBase /blog/
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /blog/index.php [L]

I use similar patterns for various sites such as vfridge (see recent post “Phoenix rises“) and Snip!t.  For Snip!t however I was using not a local .htaccess file, but an AliasMatch in httpd.conf, which meant I needed to ask Fiona every time I needed to do a change (as I can never remember the root passwords!).  It seemed easier (even if slightly less efficient) to move this to a local .htaccess file:

RewriteEngine On
RewriteBase /
RewriteRule ^(.*)$ code/top.php/$1 [L]

The intention is to map “/an/example?args” into “/code/top.php/an/example?args”.

Unfortunately this resulted in a “500 internal server error” page and in the Apache error log messages saying there were too many internal redirects.  This seems to be a common problem reported in forums (see here, here and here).  The reason for this is that .htaccess files are encountered very late in Apache’s processing and so anything rewritten by the rules gets thrown back into Apache’s processing almost as if they were a fresh request.  While the “[L]“(last)  flags says “don’t execute any more rules”, this means “no more rules on this pass”, but when Apache gets back to the .htaccess in the fresh round the rule gets encountered again and again leading to an infinite loop “/code/top/php/code/top.php/…/code/top.php/an/example?args”.

Happily, mod_rewrite thought of this and there is an additional “[NS]” (nosubreq) flag that says “only use this rule on the first pass”.  The mod_rewrite documentation for RewriteRule in Apache 1.3, 2.0 and 2.3 says:

Use the following rule for your decision: whenever you prefix some URLs with CGI-scripts to force them to be processed by the CGI-script, the chance is high that you will run into problems (or even overhead) on sub-requests. In these cases, use this flag.

I duly added the flag:

RewriteRule ^(.*)$ code/top.php/$1 [L,NS]

This should work, but doesn’t.  I’m not sure why except that the Apache 2.2 documentation for NS|nosubreq reads:

NS|nosubreq

Use of the [NS] flag prevents the rule from being used on subrequests. For example, a page which is included using an SSI (Server Side Include) is a subrequest, and you may want to avoid rewrites happening on those subrequests.

Images, javascript files, or css files, loaded as part of an HTML page, are not subrequests – the browser requests them as separate HTTP requests.

This is identical to the documentation for 1.3, 2.0 and 2.3 except that quote about “URLs with CGI-scripts” is singularly missing.  I can’t find anything that says so, but my guess is that there was some bug (feature?) introduced 2.2 that is being fixed in 2.3.

WordPress is immune from the infinite loop as the directive “RewriteCond %{REQUEST_FILENAME} !-f” says “if the file exists use that without rewriting”.  As “index.php” is a file, the rule does not rewrite a second time.  However, the layout of my files meant that I sometimes have an actual file in the pseudo location (e.g. /an/example really exists).  I could have reorganised the complete directory structure … but then I would have been still fixing all the broken links now!

Instead I simply added an explicit “please don’t rewrite my top.php script” condition:

RewriteEngine On
RewriteBase /
RewriteCond %{REQUEST_URI}  !^/code/top.php/.*
RewriteRule ^(.*)$ code/top.php/$1 [L,NS]

I suspect that this will be unnecessary when Apache upgrades to 2.3, but for now … it works

Catchable fatal error: Object of class AbcTest could not be converted to string in {dir}/PHPUnit/Framework/TestFailure.php on line 98

The error happens in the PHPUnit_Framework_TestFailure::toString method, which tries to implicitly convert a test case to a string.

The class AbcTest is my test case, which it is trying to display following a test failure.  PHPUnit test cases all extend PHPUnit_Framework_TestCase and while this has a toString method it does not have the ‘magic method‘ __toString required by PHP 5.2 onwards.

To fix the problem I simply added the following method to the class PHPUnit_Framework_TestCase in PHPUnit/Framework/TestCase.php .

public function __toString()
 {
 return $this->toString();
 }

I am using PHPUnit 3.4.9, but peeking at 3.5.0beta it looks the same.  I’m guessing the PHPUnit_Framework_TestFailure::toString method is not used much so has got missed since the change to PHP 5.2.x.

PHPUnit is now in GITHub so I really ought to work out how to submit corrections to that … but another day I think.

I mentioned ‘Project Phoenix’ in my last previous post, and this was it – getting vfridge up and running again.

Ten years ago I was part of a dot.com company aQtive¹ with Russell Beale, Andy Wood and others.  Just before it folded in the aftermath of the dot.com crash, aQtive spawned a small spin-off vfridge.com.  The virtual fridge was a social networking web site before the term existed, and while vfridge the company went the way of most dot.coms, for some time after I kept the vfridge web site running on Fiona’s servers until it gradually ‘decayed’ partly due to Javascript/DOM changes and partly due to Java’s interactions with mysql becoming unstable (note very, very old Java code!).  But it is now back online

The core idea of vfridge is placing small notes, photos and ‘magnets’ in a shareable web area that can be moved around and arranged like you might with notes held by magnets to a fridge door.

Underlying vfridge was what we called the websharer vision, which looked towards a web of user-generated content.  Now this is passé, but at the time  was directly counter to accepted wisdom and looking back seem prescient – remember this was written in 1999:

Although everyone isn’t a web developer, it is likely that soon everyone will become an Internet communicator — email, PC-voice-comms, bulletin boards, etc. For some this will be via a PC, for others using a web-phone, set-top box or Internet-enabled games console.
…

The web/Internet is not just a medium for publishing, but a potential shared place.

Everyone may be a web sharer — not a publisher of formal public ‘content’, but personal or semi-private sharing of informal ‘bits and pieces’ with family, friends, local community and virtual communities such as fan clubs.

This is not just a future for the cognoscenti, but for anyone who chats in the pub or wants to show granny in Scunthorpe the baby’s first photos.

Just over a year ago I thought it would be good to write a retrospective about vfridge in the light of the social networking revolution.  We did a poster “Designing a virtual fridge” about vfridge years ago at a Computers and Fun workshop, but have never written at length abut its design and development.  In particular it would be good to analyse the reasons, technical, social and commercial, why it did not ‘take off’ the time.  However, it is hard to do write about it without good screen shots, and could I find any? (Although now I have)  So I thought it would be good to revive it and now you can try it out again. I started with a few days effort last year at Christmas and Easter time (leisure activity), but now over the last week have at last used the fact that I have half my time unpaid and so free for my own activities … and it is done

The original vfridge was implemented using Java Servlets, but I have rebuilt it in PHP.  While the original development took over a year (starting down in Coornwall while on holiday watching the solar eclipse), this re-build took about 10 days effort, although of course with no design decisions needed.  The reason it took so much development back then is one of the things I want to consider when I write the retrospective.

As far as possible the actual behaviour and design is exactly as it was back in 2000 … and yes it does feel clunky, with lots of refreshing (remember no AJAX or web2.0 in those days) and of course loads of frames!  In fact there is a little cleverness that allowed some client-end processing pre-AJAX².    Also the new implementation uses the same templates as the original one, although the expansion engine had to be rewritten in PHP.  In fact this template engine was one of our most re-used bits of Java code, although now of course many alternatives.  Maybe I will return to a discussion of that in another post.

I have even resurrected the old mobile interface.  Yes there were WAP phones even in 2000, albeit with tiny green and black screens.  I still recall the excitement I felt the first time I entered a note on the phone and saw it appear on a web page   However, this was one place I had to extensively edit the page templates as nothing seems to process WML anymore, so the WML had to be converted to plain-text-ish HTML, as close as possible to those old phones!  Looks rather odd on the iPhone :-/

So, if you were one of those who had an account back in 2000 (Panos Markopoulos used it to share his baby photos ), then everything is still there just as you left it!

If not, then you can register now and play.

1. The old aQtive website is still viewable at aqtive.org, but don’t try to install onCue, it was developed in the days of Windows NT. [back]
2. One trick used the fact that you can get Javascript to pre-load images.  When the front-end Javascript code wanted to send information back to the server it preloaded an image URL that was really just to activate a back-end script.  The frames  used a change-propagation system, so that only those frames that were dependent on particular user actions were refreshed.  All of this is preserved in the current system, peek at the Javascript on the pages.    Maybe I’ll write about the details of these another time. [back]

I’ve had a PHP syntax checker on meandeviation for several years, but only checking PHP 4 as that is what is running on the server.  However, I had an email asking about PHP 5 , so now there is a PHP 5 version too

The syntax checker is a pretty simple layer over the PHP command line option “php -l” and also uses the PHP highlight_file function.  The main complication is parsing the HTML outputs of both as they change between versions of PHP!

There is also a download archive so you can also have it running locally on your own system.

1. watch this space … [back]

I’ve just been fixing it and posting a patch², interestingly the bug was partly due to the fact that back-references in regular expressions count from the beginning of the regular expression, making it impossible to use them if the expression may be ‘glued’ into a larger one … lack of referential transparency!

For anyone having similar problems, full details and patch below (all WP and PHP techie stuff).

The regex returned by get_shortcode_regex() in shortcodes.php had a back-reference ‘\[\/\2\]‘ to match balanced tag-end-tag pairs such as “[x]text[/x]“.  The regex assumes it will be used ‘bare’ as a regular expression.  However, wpautop in formatting.php (which turns newlines in posts into <p>s or <br>s) needs to remove <p>s form standalone shortcodes. To do this it adds extra enclosing brackets to the shortcode regex to be able to refer to the entire matched tags and content.  This means that the back-reference instead matches the (optional) preceding letter which is usually blank and thus the closing tag does not match properly.

In the case of single tag-end-tag pair, this means that

 [divtag]

 abc

 [/divtag]

ends up as

 <div>

 <p>abc</p>

 <p></div></p>

This gets more complicated when there are internal tags such as:

 [mytag] some [specialsymbol] text [/mytag]

As in some cases the existing .*? for attribute matching chomps everything while it tries to find a ‘/’.

A simple fix would be to add an optional parameter to get_shortcode_regex($nested=0) and use this to modify the regular expression.  This would give the intended match for the shortcode regex, but in fact makes things worse. Looking at the same source:

 [divtag]

 abc

 [/divtag]

it would generate (assuming [divtag] generates a div):

 <div></p>

 <p>abc</p>

 <p></div>

The attached patch addresses this by adding two new functions to shortcodes.php returning regular expressions for matching begin and end tags separately.  wpautop then has two separate preg_replace lines doing the <p> fixes.  I’ve tried to change as little as possible, although sometime might return to do things like extend it to allow nested copies of the same tag.

At the same time as doing the abve bug fix,  I swopped the .*? for attribute matching to [^\]]*?
I guess slightly slower, but doesn’t risk chomping the entire post as a shortcode attribute :-/

Download: shortcodes patch
Instructions for installing patches at Mark Jacquith‘s entry on My WordPress Toolbox.

The patch in full:

Index: wp-includes/shortcodes.php
===================================================================
--- wp-includes/shortcodes.php    (revision 11744)
+++ wp-includes/shortcodes.php    (working copy)
@@ -175,10 +175,40 @@
 $tagnames = array_keys($shortcode_tags);
 $tagregexp = join( '|', array_map('preg_quote', $tagnames) );

-    return '(.?)\[('.$tagregexp.')\b(.*?)(?:(\/))?\](?:(.+?)\[\/\2\])?(.?)';
+    return '(.?)\[('.$tagregexp.')\b([^\]]*?)(?:(\/))?\](?:(.+?)\[\/\2\])?(.?)';
 }

 /**
+ * Retrieve the shortcode regular expression for searching for start tag only.
+ *
+ * @uses $shortcode_tags
+ *
+ * @return string The shortcode start tag search regular expression
+ */
+function get_shortcode_start_regex() {
+    global $shortcode_tags;
+    $tagnames = array_keys($shortcode_tags);
+    $tagregexp = join( '|', array_map('preg_quote', $tagnames) );
+
+    return '\[('.$tagregexp.')\b([^\]]*?)(?:(\/))?\]';
+}
+
+/**
+ * Retrieve the shortcode regular expression for searching for end tag only.
+ *
+ * @uses $shortcode_tags
+ *
+ * @return string The shortcode end tag search regular expression
+ */
+function get_shortcode_end_regex() {
+    global $shortcode_tags;
+    $tagnames = array_keys($shortcode_tags);
+    $tagregexp = join( '|', array_map('preg_quote', $tagnames) );
+
+    return '\[\/('.$tagregexp.')\]';
+}
+
+/**
 * Regular Expression callable for do_shortcode() for calling shortcode hook.
 * @see get_shortcode_regex for details of the match array contents.
 *
Index: wp-includes/formatting.php
===================================================================
--- wp-includes/formatting.php    (revision 11744)
+++ wp-includes/formatting.php    (working copy)
@@ -170,7 +170,8 @@
 if (strpos($pee, '<pre') !== false)
 $pee = preg_replace_callback('!(<pre[^>]*>)(.*?)</pre>!is', 'clean_pre', $pee );
 $pee = preg_replace( "|\n</p>$|", '</p>', $pee );
-    $pee = preg_replace('/<p>\s*?(' . get_shortcode_regex() . ')\s*<\/p>/s', '$1', $pee); // don't auto-p wrap shortcodes that stand alone
+    $pee = preg_replace('/<p>\s*?(' . get_shortcode_start_regex() . ')\s*<\/p>/s', '$1', $pee); // don't auto-p wrap shortcodes that stand alone
+    $pee = preg_replace('/<p>\s*?(' . get_shortcode_end_regex() . ')\s*<\/p>/s', '$1', $pee);   // check both start and end tags

 return $pee;
 }

1. see section “using dynamic binding” in What’s wrong with dynamic binding? [back]
2. TRAC ticket #10490 [back]

So is it really so bad?

tiny-screen coding and literate programming

This issue came to mind because I’ve been considering what programming language support might be like for tiny screens (and I mean mobile phone not laptop!).  This was prompted by group discussions at the Mobile Design Dialogue conference last year² and at a bootcamp session at the Winter School on Interactive Technologies in Bangalore in February.

One of my first thoughts was that something akin to literate programming might provide a useful contribution as it allows details to be elided.  For example:

@{obtain email address from form variables}
if @{check email address valid}
then @{produce bad email error message}
else @{send email message}

The placeholders (such as “check email address valid”) are then defined separately.  In Knuth’s original WEB (and Harold Thimbleby’s cweb), all the definitions are in a single file, but in a phone-based environment this would be more like a hypertext — indeed reminiscent of the code browsers I worked on when I first came into computer science!

Using this form of named fragments would mean that one could have much smaller snippets of code on screen at any moment of time, basically substituting abstraction for scrolling, hence the reason for thinking this could be good for tiny-screen coding.

However, the semantics of these fragments in literate programming is textual inclusion, basically macro expansion.  Amongst other things this means effectively dynamic scoping; for example, the code “obtain email address from form variables” might define a variable “email” that is then used in “send email message “.

However, the dynamic scoping is quite limited as the code fragments were always (or maybe normally) only used in one place, that is they are merely a way of hiding code.  This is quite different from a piece of code that takes different meaning wherever you place it dependent on what variables it picks up.

scripts and templates

As I began to think about this I recalled early templating languages I developed for code generation from data types (somewhat similar to current web scripting languages).  In these I used abstractions that were partly like a procedure, but also, similar to literate programming, in that ‘parameters’ could be extracted from context if not given explicitly.  In the example earlier a ‘procedure’ like “check email address valid ” might have an explicit parameter  ‘email’, but this would be taken from the environment if it was not set explicitly.  This reflects the fact that in many situations there is an ‘obvious’ parameter, just as in day to day life you just say “post the letter”, not “post the letter that is on the hall table just where you will obviously find it as you go out and where I always put it”.

While this still seems a little heretical when implemented as part of a programming language (or at least templating script), in fact it is common at the meta-coding level of ‘includes’ found in most web scripting including JSP.  For example in PHP one might write:

<?php
foreach ( $messages as $message ) {
    include "format-message.php";
}
?>

The PHP code in the file ” format-message.php ” is effectively textually included inside the ‘foreach’ block and hence ‘$message’ would be available to it as a variable.  While the base language is largely lexically scoped, the includes effectively allow an alternative abstraction with dynamic binding.  Purists would might decry the above code, but few have not  used something similar at some point. Indeed the WordPress plugin system depends entirely on careful use of such constructs.

In my websites (e.g. hcibook.com/e3, snipit.org) I typically have a ‘top.php’ function that routes raw URLs to appropriate pages or scripts by use of ‘include’³.  Often this performs common start-up actions such as establishing database connections, reading Cookies, or parsing URL path information, and, of course, the results of all of this are then available as context for the included scripts.  Sometimes I wrap this in a single global variable $context, but not always (life is short, and the sensible time to code a website shorter!).

aggregate inheritance

In a HTML document, the font of a paragraph is set not by some form of object inheritance based on the class of the <p> tag, but instead on the smallest enclosing block that has an explicit font style.  The binding of fonts is in a sense static or even lexical as it is based on where in the document structure the text sits, but it is not about the lexical structure of the CSS, but of the HTML document to which it is applied.

Similarly, in a GUI a mouse click on a button will typically go through a hierarchy where the enclosing elements (screen panel, etc.) get ‘first dibs’ to filter or react to the event, eventually dribbling down to the button itself, and then sometimes back up again with the containers getting a chance to do some sort of ‘after the event’ processing.  Just like the font on the page, the meaning of ‘click on button’ cannot be found solely in the class structure of ‘JButton’, but in the dynamic location where it is found.

I don’t know a standard term for this, but I have always called it ‘aggregate inheritance‘ as elements inherit from the containers within which they are aggregated.

While lexical binding is about the structure of the code, normal dynamic binding is about the structure of the process (calling pattern) and aggregate inheritance is about the structure of the data.

the bad and the worse

The reasons for eschewing dynamic binding were partly about efficient compilation of block-structured languages, albeit now with complex object inheritance rules, dynamic binding seems tame!  The other reason was semantic as static (and especially lexical) binding allows a limited form of referential transparency, you can tell what a variable means and track the data flow — locality.

Clearly at one stage the jury was still out, indeed one of the innovations (I believe) in Algol 68 was the inclusion of dynamic binding and as late (sic) as 1986 papers were discussing ways of implementing dynamic binding⁴.  However, even Lisp eventually moved to making its default binding static.

Today all major languages use lexical binding — except they don’t.  In fact there are numerous workarounds, just like the tortured workarounds we use for GOTO-less code⁵.

Simple object inheritance is static, but only so long as no one changes the classes you inherit from!  Of course OO inheritance is itself often criticised, but is generally accepted as OK⁶.

In even simple code we also use global variables, which while static in scope certainly allow non-local effects.  These are again especially common in web scripting where context seems particularly important. In fact they are so ubiquitous that special language constructs may be used such as PHP’s ‘superglobals‘ or ‘define‘. On the client side also, Javascript code is often replete with globals.

Those using ‘proper’ languages may look down on slack web programming practices.  However, the popular singleton pattern or static Class variables (such as in the Java System class) are but globals by another name, and database access and the filesystem again access a large global name space.

But if the problem of dynamic binding is non-locality, surely the worst culprits are pointers and references.  Pure functional programming takes referential transparency seriously, is side effect free and so avoids updatable references and pointers.  However, few programmers, however pure, are willing to work totally under FP’s strictures⁷.

Non-locality of reference and effect seems, not just common but ubiquitous.  It is dangerous, but that is because it is powerful.  This is true of pointers, but equally of variable binding paradigms, the issue is how to ensure understanding and control of non-locality, not to forbid some kinds whilst allowing free reign to others.

context and pipelines

I’ve used the term ‘context’ several times.  In ubicomp and intelligent interfaces issues connected with context are critical in interpreting user activity.  Similarly, natural language processing and vision at first (many years ago), took a very pure layered approach with each level of processing giving its results to the next up in a pipeline: lexical to syntactic to semantic.  However, human interpretation is not so neatly layered⁸.  Both NLP and computer vision became a lot more successful when they allowed downwards paths from semantics back down to lower levels.

Compiler and language design took their form partly based on early models of language, indeed any cross-over between layers of processing was deemed problematic⁹.  Whilst AI seems to have moved on, programming language design does not; in language and the physical world we assume that terms take meaning from context, why not in programming?

using dynamic binding

Recently I was writing shortcodes in a WordPress plugin.  Shortcodes are tags in the text of a blog item that can be used as a form of extensible markup.  For example “[cite key=Dx09]” in the text might lookup and link to an entry in a bibliographic database¹⁰.  Some of the codes are stand alone, but some come in pairs [/code]

Being a typical hacker, I first of all created a generic helper plug-in (SimpleShortcodeHandler) that made it easy to do simple things like add a span or div with a specific class.  However, I was aware that I might want to add more complicated things like a BibTeX-style bibliography list:

[bibliography format=APA"]
[bibitem key="Dx09 "] A. Dix (2009).
    What's wrong with dynamic binding? [/bibitem]
[bibitem key="Dy68"] Dykstra, E. (1968).
    GoTo … [/bibitem]
[/bibliography]

The behaviour of the '[bibitem]' codes would clearly need to depend on the format of the bibliography, but the normal shortcode extension mechanism means (as in all good programming!) the code to process each shortcode is in isolation applied to its own text.  As a simple addition, the SimpleShortcodeHandler class keeps a stack of enclosing shortcodes in a post so that the handler for 'bibitem' can query the stack for the most recent enclosing 'bibliography' tag.  That is, I added a workaround for dynamic binding in the program code to enable aggregate inheritance in the blog post.

In fact, the way WordPress processes shortcodes means that the code for 'bibitem' is called within a call to the expansion code for 'bibliography', however, there are intervening calls to WordPress' internal functions, so one cannot simply pass in context information as an additional parameter.

Similar but more complex issues arise when dealing with sessions in web applications, AJAX programming, or other asynchronous remote procedure calls, all of which are basically an extreme case of program  inversion as found following structure clash in old Jackson Structured Programming, or more generally in co-routine-based coding.

adding dynamic binding to the language

There seem to be two forms of dynamic binding that are commonly used.

The first is shallow dynamic binding, for things like the literate programming and PHP includes.  Here the dynamic binding is almost a form of implicit parameter passing, a convenient shortcut for writing code like:

function do_some_work_to_x(x) { . . . }
// . . . later in the code
x = 3;
do_some_work_to_x(x);

The expanded code may update variables as well as use their values, but that is then like passing variables by reference.

When using PHP includes that are doing work (e.g. web page templates, as opposed to declaring functions) I usually add a comment block at the top saying what variables it expects to find in its environment.  There is no reason why this should not be made more explicit, whether hand written, or generated by a programming environment.

The second form is deep dynamic binding as in the shortcode stack described above, and indeed in many forms of meta-level programming where there is aggregate inheritance on a data structure.  In these examples, the dynamic binding is to variables that are connected to a module or similar namespace, but where the scoping of the namespace is not the call structure.

In the shortcode example, this simply was a means to pass information up and down to related functions, 'skipping' other 'foreign' functions on the way.

However, in other cases there may be a more complex pattern of scoping the context. A simple example would be for having variable 'constants' in a mathematical function class:

module Math {
  context { precision = 0.0001; base = 10; }
  sqrt(x) {
      y = 1;
      while ( abs(y*y-x)> precision )
          y = (y+x/y)/2;
      return y;
  }
}

Then in the calling code something like:

Math.push_context;
Math.precision=0.1;
z = sqrt(2);
Math.pop_context;

To some extent this form of deep context is relatively easy to manage through coding patterns, but the ubiquity in transactional, asynchronous and co-routine programming, suggests deeper infrastructure support would be useful.

in short

In dealing with the lack of good mechanisms for dynamic binding, programmers are often forced into workarounds that are worse than if there were a simple way to do it in the language.  The non-locality problems of dynamic binding are also present in other accepted programming constructs such as pointers.  On the other hand, there are many contexts, especially in web programming, where forms of dynamic binding lead to neater, more comprehensible, and hence more robust and maintainable code. Dynamic programming can be dangerous and the overall approach of the past 20 years has been to hope it will go away. However, its ubiquity and utility suggests that including support for safe and appropriate dynamic binding in tools, frameworks or languages (and the three can be conflated) may be a better approach for the future.

1. Strangely also the days when major advances in substance seemed to be more important than minor advances in nomenclature [back]
2. Recently Ken Banks, Matt Jones and Gary Marsden who proposed the MDD discussion are amongst the partners in a new project ‘mobility‘, which is planning to work on mobile-based programming tools. [back]
3. Similar to the pattern proposed by Joseph Scott in “PHP URL Routing (PUR)“ [back]
4. e.g. Gantenbein, R. E. and Jones, D. W. 1986. Dynamic binding of separately compiled objects under program control. In Proceedings of the 1986 ACM Fourteenth Annual Conference on Computer Science (Cincinnati, Ohio, United States). CSC ’86. ACM, New York, NY, 287-292. DOI= http://doi.acm.org/10.1145/324634.325436 [back]
5. The argument for avoiding where possible GOTOs was of course clearly made by Dijkstra in “Go To Statement Considered Harmful” (Communications of the ACM, Vol. 11, No. 3, March 1968, pp. 147-148). However, see the example of an LR parser in David Tribble‘s commentary on Dijkstra’s paper.  The parser would typically be coded now-a-days using a number of state variables, obfuscating the meaning far more than the controlled use of GOTO. [back]
6. Oddly, whilst inheritance is deemed OK, for some reason mix-ins are avoided in Java and indeed most modern OO languages.  This seems to be due to some of the semantic quagmire of multiple-inheritance, but mix-ins can be made semantically innocuous and would be so useful!  To some extent Aspect-Oriented Programming has some of the feel of mix-ins, and can be used to solve some similar problems; however it too brings issues of locality and transparency. [back]
7. Although Google’s MapReduce shows functional programming can be very powerful.  Having worked with FP people for many years, I find much of my own code has an FP feel. [back]
8. In particular, semantic levels of processing ‘pass down’ context to lower levels so that they ‘know what to expect’ and so can disambiguate stimuli.  To some extent we see and hear what we expect, hence various forms of optical illusion. [back]
9. For example, in K&R C, the expression: “kind (*fun)();” is syntactically ambiguous unless you know whether ‘kind’ is a user defined type. This rare cross-over between syntax and semantics was seen as a weakness in the language. [back]
10. I’m writing plugin’s to help write the TouchIT book [back]

The rest of this post has moved to a permanent page at:

http://www.alandix.com/blog/code/sorter/