It was still surprising that the bulk of what I wanted to do can be done in about 16 lines of code. That’s right: sixteen.

The plan was to create an edit-in-place system that would degrade nicely in browsers with JavaScript disabled. This isn’t necessarily as elegant as it could be and it doesn’t yet handle all input types, but that’s what version one is for! So without further ado, I present the code:

$.fn.in_place_edit = function() {

  this.each(function() {

    var $eip = $('<span></span>');

    var $el=$(this).hide().after($eip);

    $eip.text($el.val());

    $eip.click(function(){ $eip.hide(); $el.data('origval', $el.val()).show().focus().select(); });

    $el.blur(function(){

      if($el.is('select')) $el.data('origval', $el.val());

      $eip.text($el.data('origval')).show(); $el.hide().val($el.data('origval'));

    });

    $el.keydown(function(e){

      if (e.which==27) $el.val($el.data('origval')).blur();

      if (e.which==13||e.which==9) {

        e.preventDefault();

        $el.data('origval', $el.val()).blur();

      }

    });

  });

};

Usage:

$(function(){ $('input, select').in_place_edit(); });

So, what does all this do? First of all, we create a new function on the main jQuery object, called in_place_edit. This then iterates over elements matching the selector. It hides the input and creates a placeholder <span> element with the input’s value. Then we simply set up event handlers to deal with the placeholder being clicked, the input losing focus, and various keypresses (enter/tab to accept, esc to cancel). To see it in action, I’ve put together a rough-and-ready demo.

Planned future enhancements:

• Checkbox input types (display using the labels?)
• Radio input types
• File input types (if possible)
• Textareas
• Any other types…

Maybe further updates later on!

Apache module

The first thing I have in mind is to create an Apache 2.2 module that uses the APR (Apache Portable Runtime) to make configuration file templating easy.

On my server, there are a lot of very similar Apache configuration files. At the moment, they are semi-automatically generated by running a Perl script that reads the configuration from a database and then creates the output files as required. This is all well and good, but changing anything requires running the Perl script, regenerating all of the configuration files, then prodding Apache to reload its configuration. There has to be a better way, especially one that doesn’t require elevated permissions like that.

Enter my proposed solution: mod_sqltemplate. This module will add a few extra settings and (at least) two extra sections to the standard Apache configuration. The propsed features are:

• SQLTemplate_DBDriver «driver» – sets the APR driver to be used
• SQLTemplate_DBOpts «option-string» – options for the driver (e.g. database name, username, password…)
• SQLTemplate_Caching «on|off» – enable/disable configuration caching
• SQLTemplate_CacheDir «path» – directory in which to save cached configurations
• <SQLRepeat «query»> – new section, as described below
• <SQLCatSet «sep» «query»> – new section, as described below

SQLRepeat

The SQLRepeat section is probably going to be the most-used new directive. It provides templating functionality similar to mod_macro, although the template variables are taken from the column names of the query rather than being explicitly specified. The section will then be repeated for each row of the resultset, substitutions occurring as required.

Perhaps an example would help:

<SQLRepeat "SELECT id,hostname,domain FROM apache_hosts">
<VirtualHost *:80>
  DocumentRoot /var/www/${hostname}.${domain}
  ServerName ${hostname}.${domain}
  # ...
</VirtualHost>
</SQLRepeat>

For this example, I’ve avoided the configuration directives for clarity, assuming they are specified elsewhere. Supposing the database table contains simply:

Then this will expand to be equivalent to:

<VirtualHost *:80>
  DocumentRoot /var/www/www.example.com
  ServerName www.example.com
  # ...
</VirtualHost>
<VirtualHost *:80>
  DocumentRoot /var/www/test.example.com
  ServerName test.example.com
  # ...
</VirtualHost>
<VirtualHost *:80>
  DocumentRoot /var/www/yourhost.somewhere.local
  ServerName yourhost.somewhere.local
  # ...
</VirtualHost>

And so on. These sections can be nested, so if you wanted to store a list of aliases as well:

You could use something like this:

<SQLRepeat "SELECT id,hostname,domain FROM apache_hosts">
<VirtualHost *:80>
  DocumentRoot /var/www/${hostname}.${domain}
  ServerName ${hostname}.${domain}
  # ...
  <SQLRepeat "SELECT alias,target FROM apache_aliases WHERE hostid=?" ${id}>
    Alias "${alias}" "${target}"
  </SQLRepeat>
</VirtualHost>
</SQLRepeat>

which would then expand to:

<VirtualHost *:80>
  DocumentRoot /var/www/www.example.com
  ServerName www.example.com
  # ...
    Alias "/icons" "/var/www/_share/icons"
    Alias "/example" "/var/www/_share/foo"
</VirtualHost>
<VirtualHost *:80>
  DocumentRoot /var/www/test.example.com
  ServerName test.example.com
  # ...
</VirtualHost>
<VirtualHost *:80>
  DocumentRoot /var/www/yourhost.somewhere.local
  ServerName yourhost.somewhere.local
  # ...
    Alias "/bar" "/var/www/_share/foo"
</VirtualHost>

So far, so good. Something to note is that the variable names above did not conflict. If we had included “id” in the list of columns for the inner SQLRepeat, then included ${id}, the module should use the innermost scope. Disambiguation should be obtained by table alias prefixing (e.g. ${apache_hosts.id} or ${apache_aliases.id}). Full variable names should always be specified for clarity. This also shows that if the query returns no results, the repeating section is not included, as you would expect. Also note that queries that use variable substitution should use the prepared statement format, with variables specified afterwards. Variables will be included directly, so anything that might contain spaces must be quoted.

However, there are some directives like ServerAlias that must be specified once with a list of space-separated values. Enter SQLCatSet…

SQLCatSet

This acts in a similar way to SQLRepeat, but it concatenates all of the results for each field before substituting, and it includes its content at most once. If there are no results for the query, then it will not include its content. For example, with a server aliases table like:

You could use something like this:

<SQLRepeat "SELECT id,hostname,domain FROM apache_hosts">
<VirtualHost *:80>
  DocumentRoot /var/www/${hostname}.${domain}
  ServerName ${hostname}.${domain}
  <SQLCatSet " " "SELECT alias FROM apache_server_aliases WHERE hostid=?" ${id}>
    ServerAlias ${alias}
  </SQLCatSet>
  # ...
  <SQLRepeat "SELECT alias,target FROM apache_aliases WHERE hostid=?" ${id}>
    Alias "${alias}" "${target}"
  </SQLRepeat>
</VirtualHost>
</SQLRepeat>

which would then expand to:

<VirtualHost *:80>
  DocumentRoot /var/www/www.example.com
  ServerName www.example.com
  # ...
    Alias "/icons" "/var/www/_share/icons"
    Alias "/example" "/var/www/_share/foo"
</VirtualHost>
<VirtualHost *:80>
  DocumentRoot /var/www/test.example.com
  ServerName test.example.com
    ServerAlias test2.example.com test.example.net
  # ...
</VirtualHost>
<VirtualHost *:80>
  DocumentRoot /var/www/yourhost.somewhere.local
  ServerName yourhost.somewhere.local
    ServerAlias *.somewhere.local
  # ...
    Alias "/bar" "/var/www/_share/foo"
</VirtualHost>

This would seem to cover the major functionality needed for automatically generating configurations in a really flexible way, although I’m sure more will probably be needed at some point… like SQLIf, perhaps.

PHP Framework

It occurs to me that having a framework’s code in PHP itself could mean that it is quite slow. It would be interesting to put together a framework in C and embedded as a module, to see if there are any memory/speed improvements possible. It might just be a case of implementing an ORM (Object Relational Model) system to begin with. Obviously, this idea is nowhere near as fully-formed!

The Idea

The basic idea is that we have a sorted list of items that may have some duplicates, say:

{A0, A1, B0, C0, C1, E0, F0, F1, F2, G0, H0, H1}

and we want to remove all of the duplicates, so we get two sets:

{A0, B0, C0, E0, F0, G0, H0} {A1, C1, F1, F2, H1}

Note that it doesn’t matter which of the duplicates ends up in which set, just that the items in the first are all unique and that we don’t lose any. Also, A₀ and A₁ have the same value but the subscript will help to distinguish exactly which of the As I’m talking about. Now we have the problem, let’s look at some solutions.

Lossless solution – additional lists

So the first solution uses two temporary lists, unique and duplicate. We start with two pointers into the original list: p and q. We set p to point to the start of the list, and q to point to the element after p. We then copy the item p points at to our unique list. Then, while we still have more items to examine:

• If the items pointed to by p and q have the same value, then we copy the item q points at to the duplicate list and advance p and q.
• If they are different, we copy the item at q to our unique list, and advance p and q.

We keep doing this until we get to the end of the array, and then copy the unique list to the start of the array, the duplicate list after that (both overwriting the previous contents) and set the number of unique items to the length of the unique

list.

Lossy solution – one list

We can do a similar thing in-place, although this will result in data loss. The essential idea is:

• We start in the same way: p pointing to the first element, and q to the second
• While q has the same value as p, advance q along the list
• When they are different, advance p, copy q to p, and advance q
• Once q goes past the end of the list, we’re done, and the offset of p is the number of unique items.

Now this is quite simple, and only requires one pass through the list, but it results in the loss of information, which is unacceptable in this case.

Lossless solution – one list

For this solution, we can also do it with one pass through the list and two pointers. The basic intuition is that we’re going through the array, accumulating a rotating block of stuff that we don’t want. At any given point:

• Everything between the start and p (not inclusive) is the unique list (so far)
• Everything between p and q (not inclusive) is an unwanted duplicate
• Everything between q (inclusive) and the end is yet to be processed.

At the end, we return the number of unique items at the start of the list; everything above that is a duplicate.

For integers

Here is some pseudo-Java that performs my algorithm for a set of integers.

int set_uniq(int set[]) {

  int count = set.length();

  int tmp, p=0, q=1;

  while (p < set.length && q < set.length) {

    while (p < set.length && set[p] != set[q]) {

      p = p + 1;

      if (q < set.length) {

        if (p < q) {

          tmp = set[p];

          set[p] = set[q];

          set[q] = tmp;

        }

        q = q + 1;

      }

      else if (count > p) {

        count = p;

      }

    }

    while (q < max && set[p] == set[q]) {

      q = q + 1;

    }

  }

  // q hit the end and is still the same as p

  if (count > p)

    count = p + 1;



  return count;

}

The general code

The arguments to the general set_uniq() function are very similar to the arguments to standard qsort():

• The (sorted) array to work on
• The number of items in the array
• The size of each item in the array
• A comparator function that returns a negative integer if the first argument is less than the second, zero if they are equal, and a positive integer if the first argument is greater than the second.

So, without further ado, my code:

int set_uniq(void *set,

    size_t count,

    size_t elem_size,

    int (*cmp)(const void*, const void*)) {

  void *p, *q, *max;

  void *tmp=calloc(1, elem_size); /* TODO: check for failure */

  p=set;

  q=set+elem_size;

  max=set+(count*elem_size);

  while (p< p-set)

      count = (p-set)/elem_size;

    }

    while (q p-set)

    count = 1 + (p-set)/elem_size;

  ifree(tmp);

  return count;

}

Conclusion

This code is released under a Creative Commons licence (see below). A similar idea will work well for other solutions, like set difference. I’ll post those later if anyone really cares. Also, there is a better way of swapping the items by using the fact that:

a ^= b;

b ^= a;

a ^= b;

swaps a and b without needing a temporary variable. If you just go along the data in 32-bit chunks, performing those XOR operations to swap the data. This actually works out to be 30% or so faster (if I remember correctly). Finally – general code like this is always going to be slower than code that’s been specialised for a particular purpose. Calling this on integers, for example, will be much slower than coding an integer-specific version. I should also point out that you can just overwrite integers, as you don’t need to free them

• More on Partis and its future
• A web service integration API proposal
• A PHP system to make it easy to plug together a load of code modules for rapid development
• Not to mention some others which are too fleeting or too vague to pin down yet

Partis

Partis is the name of a project I had originally planned to put together many years ago when I started university (back in 2004!).

The basic idea was to create a P2P system that worked internally on networks using IP multicast for peer discovery, which also allowed browsing and cross-network searches. It would provide bandwidth limitations, both in terms of speed and amount, as well as dynamic limits (e.g. 500KB/s for the first 300MB downloaded, then 50KB/s thereafter).

While I think this is still a good idea for places like the halls networks (where we were limited to 5GB bandwidth per 24 hours) I have decided on a better direction for the project, which is something almost completely different: distributed backup.

I don’t want to talk about Partis too much in this post, as I want to discuss other things too, but I will note down some of my ideas and things that have come out of discussion with others.

Changing Partis to a distributed backup solution came from a fairly selfish beginning, as have many of my ideas. If I want to put a system together because I’ll find it very useful (and perhaps indispensible) then perhaps other people will think the same. When I was getting ready to begin my final year project, I wanted to be paranoid about my work. I wanted to guard against losing it in any conceivable way:

• Hard drive or computer dying or becoming corrupted or destroyed
• Losing a USB stick
• Accidental deletion/overwriting
• Malicious tampering
• Theft
• External server failure (e.g. Department of Computing or my own server), although highly unlikely

So after considering all these options, I thought it would be great to create a distributed P2P-style backup solution. Sadly I haven’t had the time to do this, but the basic idea for myself was to use the fact that many of the computers in the Department have an empty partition that is about 20GB in size. If I could use that space to store my data and redundantly distribute it across multiple machines (to account for failures/reformats/reinstalls, computer being off or in Windows or otherwise inaccessible, etc) then I would feel a bit safer. And of course I could use some spare space on my housemates’ computers, and maybe my home computer, and my server, and some other friends around the country or even the world…

The data would have to be encrypted, of course, as I wouldn’t want just anyone reading it, and there would have to be checksums to guard against modification or corruption. I quickly realised that this project was something that I wouldn’t have the time to undertake in parallel to my Masters project, and that it might have made a viable alternative. Then of course, there’s the possibility of storing versioned copies of files, and the question of how to distribute everything, and so forth.

Then it hit me that other people would find this useful. Surely most students would want to have a gigabyte or more of redundant, safe storage? Then this creates and solves the problem of finding enough space at the same time. As a potential business model, for example, people could have 1GB of free storage by offering 3-5GB of their own disk for usage by the network.

There would be different storage tiers based on host reliability (uptime/online time/connection speed/etc) and so on. It would perhaps be possible to charge a premium for upper-tier storage (i.e. things you’d need to be able to recover ASAP) as opposed to lower-tier storage (data that you want safe but you don’t need immediate access to, e.g. family photos), with varying prices depending on the service you offer to others. The better the service you offer (the more you put in), the better you get (the more you get out). Of course, those who don’t want to contribute their resources to the network (or can’t do so) would be able to pay for some centralised storage.

It’s not just individuals who could use this system, however. Think about companies with large numbers of desktop machines in geographically distinct locations. Bump up the redundancy factor and it could be licensed as an alternative off-site backup solution. Archived data could be distributed across employees’ desktop computers, using a percentage of the disk space that would otherwise just be sitting idle. For a fee.

Of course, there are a large number of things to consider and tweak, such as how to deal with encryption, and the inevitability of people losing their keys. My first thoughts on this are to have a two-layer system, although I’m not sure this is possible. The user has a passphrase-protected key that can decrypt a secondary key which is actually centrally stored and used to encrypt/decrypt their files. Then if users lose their passphrase, their data isn’t lost – another key held in central reserve that requires a combination of personal details to unlock can be used to decrypt the secondary key and create a replacement personal keypair.

That’s probably enough about Partis for now!

Update (2008-04-29 18:25): Dan Lester (who uses the same WP theme – what are the chances?) has drawn my attention to Zoogmo which is similar on the surface, but is Windows-only and based around the idea of sharing with friends rather than the Partis network. Also, they don’t yet appear to have different tiers. They do have a suitable “Web 2.0″ name though. Something to look into and keep an eye on though. Are any ideas original any more?

Web service integration

Something that came to my attention the other day when reading Charles Miller’s blog was the fragmentation of data across the web. There are few central authentication schemes (such as OpenID) and little support for them. There is no standard for integrating the services offered by the multitude of different sites. This isn’t helped by the lack of incentive for sites to bring their offerings together, but I believe it could be really useful. I then read various blog posts on this subject and decided that I would like to hammer out the beginnings of a web interaction/integration API. With help and assistance from other people, of course!

More on this another time. All I will say for now is a potential name: OpenIntegrate.

Pluggable PHP system

While in the shower the other day (an excellent place for ideas to appear, it seems), I decided that what I really want to create is a library of PHP code that I can just plug together for various tasks. It would have to know a bit about database layout, so that I didn’t really have to think about it in advance. The more I thought about it, the more developed the idea became. This system would be a set of PHP files and a preprocessor, so that modules can have optional dependencies and hence conditional code generation/inclusion in a fast way, as well as automatically creating/updating the database in order to work.

For example, I was recently thinking about how persistent logins work, and how nice it would be to just write a component once that I can just add to a generic user authentication component. A user authentication component requires (at minimum) a username and password field in a users table of a database. When coupled with a persistent login cookie system, however, either the users table has to be updated to include a persistent_token field (and maybe a series_id, see here) or a new tables is required if you want to allow login to be remembered from multiple places.

It would be really nice if the PHP could take care of these database modifications by itself, and automatically integrate with the user login module, so that I don’t have to worry about it. That way, I can just put a load of files together, run something similar to rake/bake on them, and end up with an SQL file that will contain the required database schema and also include/exclude bits of the PHP code based on the available modules, perhaps commenting/uncommenting blocks based on available modules, etc. This would prevent a number of checks for optionally available functionality. Each module would then contain a comment header, perhaps something like:

/*# PROVIDES: userauth
 *# REQUIRES:
 *# SUPPORTS: persistlogin
 *# DEFAULT_DEF: TBL_USER="users"
 *# DB_REQUIRE: [ TBL_USER, [ username: varchar50, password: char32 ] ]
 */

and then:

/*# PROVIDES: persistlogin
 *# REQUIRES: userauth
 *# SUPPORTS: persistlogin
 *# DB_REQUIRE: [ TBL_USER, [ persistent_token: char32, series_id: char32 ] ]
 */

… and then make a sensible minimum required database structure out of them. Of course, much more than this would be required, and the format described above is very nasty, but that was just my first thoughts. You could then have conditional compilation:

/*# IF HAS_MODULE("persistlogin")
  // code to check for persistent login cookie
  if ($_COOKIE['persist_login']) { }
  elseif (/* check DB ... */) {
 *# ELSEIF #*/
  if (/* check DB ... */) {
/*# ENDIF #*/
    // log them in
  } else {
    // ...
  }

or:

/*# IF HAS_MODULE("persistlogin") #*/
  // code to check for persistent login cookie
  if ($_COOKIE['persist_login']) { }
  elseif (/* check DB ... */) {
/*# ELSEIF #*
  if (/* check DB ... */) {
 *# ENDIF #*/
    // log them in
  } else {
    // ...
  }

depending on whether the “persistlogin” module is available at the time the preprocessor is run.

I thought about calling it GHOTI (prounounced “fish”) because I like quirky words, but couldn’t immediately come up with a backronym. G- H- Offering Tight Integration? Maybe I’ll come up with something from Latin instead. Or call it RADPHP or PHP-RAD. Who knows?

Anyway, that’s probably enough of my random ideas for now. More to come after exams, I don’t doubt! First one is tomorrow at 14:30. Sigh.

I’ve got the source from the CoolerMaster-provided programs that deal with the device, so all I need to do is get serial communication working (9600 baud, 8 data bits, 1 stop bit, no parity or handshaking) and I should be good to go. This will have the following advantages:

1. My processor fan is connected to the FAN1 output of the CD6. It would be quite nice to software-control (and -read) its speed depending on whether I want cool operation or silence.
2. The internal HDD fan is hardwired to the FAN3 output of the CD6. It would be quite nice to software-control (and -read) its speed etc… especially as I don’t really currently use it.
3. My other case fans are currently controlled by a switch I’ve modded into a bay bevel. It would be great to take away the hardware from this too so that all fans in my computer are software-controlled. To do this, I can simply attach a couple of transistors to some cables going to FAN2, and then they will switch the fans on and off depending on whether FAN2 is on or off.

The end result? I want to be able to press a button on my keyboard (the backlight button, in fact), and turn off the backlight on my keyboard, the case fans, case glow and HDD fan, and to slow my CPU fan down to about 1700 RPM. Another press of the button will activate the backlight, case fans, case glow and HDD fan and speed the CPU fan up to 2300 RPM or so. That way, I can watch films/videos or sleep in near-silence with a simple keystroke, and go back to intense operation just as quickly. I could even decide that I wanted to do some compiling while I was away from my machine, and turn the fans on via SSH.

The possibilities are (obviously) endless.

The configuration file format is pretty simple. There are some global options that must be set, and then sections named after the directory to which they filter mail. These sections then contain some (optional) meta-actions (e.g. automatic archiving by date or automatic reply), one or more matching rules (i.e. how to decide if an email message should be processed by this rule) and then zero or more actions to be taken (the default being “save to the given folder and stop processing”). Let’s take a look at a (very simple) example:

[!GLOBAL!]
mail-root = "IMAP"
errors-to = "errors"

vacation-level = 0
vacation-alias = my.user@my.university.ac.uk myabbr@my.university.ac.uk
vacation-msg = $home/vacation/message
vacation-log = $home/vacation/log
vacation-once = $home/vacation/once
vacation-repeat = 2d

archive-path = "IMAP/archive/$1/"

[spam]
group
  header X-Spam-Flag  == "YES"
  header Subject      =~ "^((my|new)s)?PH[a-z]*A?[a-z]*R[a-z]*MA"
  header Subject      =~ "^ME[a-z]*DS"
endgroup
and
!anydomain             "my\.university\.ac\.uk"

[!UNDELIVERED!]
@ARCHIVE INBOX
@VACATION 4

saveto .email

Wow. What the hell does that all mean? Allow me to explain.

The first part deals with global settings, including:

• The root directory that mail should be stored in
• The directory that error messages should be stored in
• The current “vacation level” and other settings related to it (see later)
• The directory that automatic archive copies should be stored in (see later)

After that follows a filter rule for email to be put into /spam. I first create a nested rule that checks if the X-Spam-Flag header is set to “YES” or the subject matches one of two patterns that came up very frequently for a while. It then also checks against bizarre false positives by ensuring that the “from” domain does not match my university’s domain (or any of its subdomains, like lecturer@dept.my.university.ac.uk). Sadly, Exim is very strange about its quoting rules, and that is the reason for the multiple backslashes. Maybe that will be tidied in a future release

The final rule deals with any email that hasn’t been delivered yet, and is a special rule (as evidenced by the exclamation marks and capital letters). This rule contains two meta-actions. The first tells it to automatically archive email by date to IMAP/archive/yyyy-mm/INBOX. The next meta-action says that if the “vacation-level” variable is 4 or higher and the email was sent directly to me, automatically reply to the sender. Finally, there’s an actual action that causes the email to be saved to my .email file.

For the curious, this turns out to be something like the following, when run through autoforward:

# Exim filter  <<== do not edit or remove this line!if error_message then

  save IMAP/errors

  finish
endif

add 0 to n0

############################################################
## Dir: spam
############################################################

if (
  $h_X-Spam-Flag: is "YES"
  or $h_Subject: matches "^((my|new)\s)?PH[a-z]*A?[a-z]*R[a-z]*MA"
  or $h_Subject: matches "^ME[a-z]*DS"
)
and foranyaddress $h_From:,$h_Reply-To:
  ($thisaddress does not match "@([^@]+.)?my\\.university\\.ac\\.uk")
then

  save IMAP/spam

  finish
endif

###########
## INBOX ##
###########

if not delivered
then
  if $tod_log matches "^(....-..)" then
    save IMAP/archive/$1/INBOX
  endif

  if personal alias my.user@my.university.ac.uk alias myabbr@my.university.ac.uk
  and $n0 is above 3 then
    mail
      to $reply_address
      subject "Re: $h_subject:"
      expand file $home/vacation/message
      log  $home/vacation/log
      once $home/vacation/once
      once_repeat 2d
  endif

  save .email

  finish
endif

So, if you want to try it, see the attached script and example files, as there’s much more you can do with it!

• autoforward.pl
• autoforward.sample.conf

To run the script, you should type something like:

autoforward.pl < ~/autoforward.conf > ~/.forward

A very brief list:

• [secret project]
  • This one’s the biggie. It’s a company project, so I can’t reveal anything about it, but it should be launching this summer. Stay tuned for more information as it develops.
• RageControl
  • A website/hosting control panel system. I’m building this because I haven’t yet found a control panel system that I like, and my company will eventually be offering web hosting. At the moment, it just runs on my personal machine, but so far, so good…
• Partis
  • This could become one of many things, and it’s hard to decide exactly which direction I want to take it in. It’s either a massively distributed peer-to-peer backup system, or it’s a way of automatically synchronising groups of files. Maybe I’ll split the file synch off into another project though.
• DBFS
  • A database-based filesystem, possibly as a final (4th) year individual project for my Computing degree… It has a few novel features that I haven’t seen proposed anywhere else, but it may require me writing/modifying a database engine.

… and then there’s the Retiarius site to work on and finish, not to mention all the other hundreds of little ideas that keep surfacing!