computing (104)

Leaving aside the religious content (for the sake of this discussion), check out the Arabic text on this page. You'll have noticed it is an embedded image, but see how clearly the writing and diacritics are displayed. One would wish that Arabic text were rendered this way on a browser.

What does it take to do that, I wonder.

The current actions module does not seem to show a per-node actions list. Instead, these actions are API-callable or event-based, which is useful for some applications but not others. Specifically, the knowledge worker wants to manipulate nodes by performing standard actions on them, invoked manually from the UI.

Design:
Add an "actions" tab for the node, in addition to the existing "view" and "edit" tabs. Or, add a new section in the "edit" tab, like "Menu settings", "Authoring information", etc.

Group actions:
Select a number of nodes (using the nodelist module for example), and then act on those nodes collectively using an action (using the action module).

The idea is to recreate classical data structures (list, stack, tree, graph, etc.), but applied to Drupal nodes. This way we get structured information, and we can then apply standard computational actions (sorting, searching, etc.) to nodes directly. This is approaching a vision of programming information explicitly.

From a usability perspective, a new class of drupal objects would be created: node containers which have their own user interface. Of course, they are also nodes for recursive access.

The idea is to create a SQL-like query language to return node lists based on specified criteria.

The idea is to create a new node type that refers to a node on another Drupal installation. The node content is always fetched from the remote site, although taxonomies are local. This will reduce the amount of duplicated content and enhance cross-site linking.

A node type that implements the Composite design pattern. Nodes of this type merely refer to a list of other nodes, and they are displayed by displaying the referred nodes in order of inclusion. Composite nodes would be useful to associate nodes of different types together to form a bigger logical unit.

According to Rady, the e-world would be a better place if we had to pay for each email sent. The rationale is that people would actually think twice before sending email (instead of the current logorrhea): no more bad jokes, useless links, and probably much less spam! Take SMS for example: the percentage of short text messages I receive that deliver a useful piece of information is much higher than the percentage of equivalent emails. That's a good clue.

Finding classes in jar files must be one of the main activities of Java developers.

Here's my version of the "find in jars" utility. Note that the same idea can be used to find files inside zip or any other archive file.


#!/bin/sh
for f in `find -name '*.jar'`; do (unzip -t "$f" | grep $1) && echo "Found in: $f"; done


NOTES:
* I used `unzip` instead of `jar` because the machine I was using at the time did not have the JDK. It's too complicated to explain. To use `jar` just replace

unzip -t "$f"

with

jar tf "$f"


* The script searches in the current folder and subfolders for .jar files only. Change as appropriate.

If you're using USB drives on a Linux server, then you probably ran into the problem of mounting those drives consistently. The problem comes from the fact that the USB mounting order can change from one reboot to the next, rendering your fstab entries stale.

Fortunately, udev comes to the rescue. Just do a

ls -la /dev/disk/by-id/

and you'll find human-friendly and persistent symbolic links to the USB device nodes. For example, mine has

lrwxrwxrwx 1 root root 10 2006-09-07 08:40 usb-Maxtor_6_Y120L0_############ -> ../../sda
lrwxrwxrwx 1 root root 10 2006-09-07 08:40 usb-Maxtor_6_Y120L0_############-part1 -> ../../sda1