One of the modules that users have developed is a web services interface to Drupal. Many of the basic core features are exposed, and developers can create additional interfaces to other modules.

Unfortunately, there wasn’t much help available for Java developers. From the looks of it, AIR/Flex/Flash is getting some serious developer time right now. To support the Logo project, I developed a Java library for mobile web services with Drupal. The library is fairly basic right now, but it should be easier to get started now.

Here’s an example of using it to call the system.connect method:


ModrupalServiceClient client =
new ModrupalServiceClient(url, api_key, domain);
SystemService system = new SystemService(client);
Hashtable res = system.connect();


I’m releasing the code under the GPL 3.0. Feel free to use it for your own projects.

Modrupal mobile library for Drupal web services.

My choice for platform is currently Drupal. It has a wonderful development community that is very active. There is a rich ecosystem of modules and plugins that will let you do almost anything you can think of. Chances are, if you’re thinking about it, somebody has written a module to do it. I’m currently sketching designs for the site and what the basic interactions are.

Then today I saw the following post on ReadWriteWeb about Building sites around social objects. They point out a common pattern in social networking/media sites. These sites are usually built around objects of some type. For Facebook it’s people, but del.icio.us, it’s bookmarks, for Flickr it’s photos. But this pattern pops up again and again. I’m still going with Drupal for the site, but I’ll keep in mind the brilliant insight when designing the LOGO sharing modules.

Originally, I wrote the interpreter parser using the CUP LALR parser generator for Java. When I was evaluating whether to write the parser by hand, or use a parser generator, I decided having the ability to quickly and easily mess with the grammar was a big plus.

If you’re not familiar with parser generators like CUP or yacc, they turn compiler development into something fun. Instead of juggling finite automata and parser tables in your head, you just specify a language grammar, along with a set of semantic actions, and out comes a parser. In the case of my interpreter, the parser is outputting an abstract syntax tree (AST), which is a tree representation of the LOGO code. The interpreter then evaluates the program by walking the tree.

For example, consider the following CUP grammar rule for a REPEAT command:


loop ::= REPEAT INTEGER:n list:l
{: RESULT = new LogoRepeat((LogoCmds)l, n.intValue()); :}
;


This tells the parser that when it sees a REPEAT command in the token stream, it should emit a new AST node (LogoRepeat). LALR parsers are bottom up parsers. The AST is built up from the leaves to the root node.

So far so good. Using CUP I was able to quickly prototype the interpreter, and focus on the interface and device porting work. Then I tried adding variables and procedure arguments.

LOGO is a functional language based on LISP, except without the parentheses. LISP, aka Lots of Irritating Superfluous Parentheses. Turns out those parentheses aren’t that superfluous.

Consider the following procedure call in LOGO:

SUM SIN 90 3

This is fairly easy to parse, SIN takes one argument, SUM takes two, so the parse should look like this:

(SUM (SIN 90) 3)

The problem comes when we let users define their own procedures. How do we parse the following:

foo bar 1 2

There are three possible parses, depending on the number of arguments each procedure takes, assuming it’s a valid statement in the first place:

(foo (bar 1 2))
(foo (bar 1) 2)
(foo (bar) 1 2)


So, the correct parse depends on the number of parameters, or arity, of the function. Unfortunately, that information is not available at the level of the syntactic parser, it’s gained through semantic analysis. The LOGO language is not context-free (this is equivalent to example 4.12 in the first edition of the dragon book. Languages like LISP and C have those wonderful parentheses indicating the begin and end of procedure calls.

So, how do we fix this? One solution is to feed semantic information into the syntactic parsing stage. Procedures and variables are kept in a symbol table, which can be referenced in semantic actions while parsing to disambiguate the grammar. This complicates the simple mapping of the grammar to the AST, reducing the readability of it. I didn’t find a way of dynamically modifying the parser with CUP or JFlex, so I started exploring some other Java parser generators. Unfortunately, ANTLR uses several Java foundation classes that are not included in the MIDP 2.0 standard.

So, it’s back to writing the parser by hand. Which is actually a lot more fun than I first thought. Steve Yegge is right, if you don’t know compilers, you don’t know computers. For that matter, you don’t really know programming languages either. Compiler design touches every aspect of computer science. It also changes the way you think. Programs stop being static objects you write, and turn into dynamic evolving structures.

One of those passions is educational software. Does anyone remember LOGO? Turtle graphics? For a brief period in the late 70s and early 80s, thousands of schools throughout the country introduced children to a computer language called LOGO. Kids could program a little computer turtle (usually represented as a triangle) to move around on screen. The creators of Logo (primarily Seymour Papert) saw it as a revolutionary new educational philosophy. The idea was to get children actively involved in the learning process. Students learn by actually creating and interacting with their world.

LOGO has since died off, but it impacted a lot of people, including myself. For an entrepreneurship course this past semester, we wrote business plans. My business plan was for a software company that designs revolutionary educational mobile software. Software like LOGO and Robot Odyssey.

So, over the past week, I’ve been working on a LOGO implementation for cell phones. I have an initial version running now, which you can see below in an emulator:

It looks simple, but underneath that simplicity is a full programming language. To assist users who are on cell phones without keyboards, I used a menu system like the one used in the wonderful Calc project:

I’ve got versions working for MIDP 2.0 devices and current generation (Pearl on up) BlackBerry devices. You can download them from the URLs below:

BlackBerry COD file

J2ME jad file
J2ME jar file

One the surface, they’re right. For the most part, many of them will be using already existing classification systems and existing programming libraries so they don’t have to think about that stuff.

But underneath the surface, recursion is a fundamental principle of nature. Chomsky got that when he developed his theory of syntax. And it extends beyond language to the entire human mind (for a great introduction to recursion and cognitive science, check out Godel, Escher, Bach: An Internal Golden Braid). And even on the surface we see signs of recursion, from ferns and trees to nautilus shells, they all show recursive patterns. This isn’t just some abstract mathematical mumbo-jumbo. Understanding trees and recursion will better help you model information about the real world.

As a librarian, if you’re designing a new classification scheme, chances are you’re designing a tree, or a series of trees (also called a forest.) Understanding trees and search on trees is going to help you help your users find information faster.

To be sure, recursion isn’t an easy concept to grasp. Everyone suffering through 503 should keep in mind that many computer science students are also having trouble with the idea of recursion. I’d be willing to bet that a good majority of computer science graduates don’t actually “get” recursion. Sure, they all had to write a fibonacci sequence generator for their introductory programming course, but after that it was kind of forgotten (which might explain why so many have problems with their compilers and interpreters course work).

And of course, all of this work shows another important core principle from 503, the idea of “divide-and-conquer” algorithms and logarithms. They’re all related.

Part of the reason I applied to the School of Information was an interest in mobile ad-hoc networks (commonly called mesh networks) and social issues on those networks. It’ll be interesting to see how the OLPC project deals with issues such as free-riders and free-loaders on the mesh.

C-SPAN’s RSS feeds and audio/video files are made available free of charge for use by individuals for personal, non-commercial uses, but they are still fully protected by copyright.

Except as specifically permitted by this policy, C-SPAN’s RSS feeds and audio/video files may not be used for any political, commercial or otherwise unauthorized purpose. Any posting, retransmission, sale, public performance or other unauthorized duplication of the audio/video files is strictly prohibited.

One thing I noticed is that they don’t allow you to use the content for “political” purposes. That’s a rather strange restriction. Why else would I want to use political videos if not for political purposes. I assume this doesn’t include parody, but it is an unnecessary restriction that could ensnare bloggers and artists. In fact, it seems to go against the very reason they proclaim in their press release:

“As technology advances, we want to continue to be a leader in providing citizens with the tools to be active participants in the democratic process.

Wouldn’t letting people use your content for political purposes help them become active participants, and not just viewers and consumers?

Blackboard was recently awarded a broad patent covering a lot of elearning tech., most of it with prior art. Tim O’Reilly has a great writeup on the story.

Well, it turns out there’s more. Pamela Jones of Groklaw has an article in LWN talking about Microsoft investing in Blackboard. Considering their SCO connection, this strongly hints at a Microsoft attack on open source by proxy.

Libraries would be a perfect environment for distributed storage. Obviously, we always need space. We’ve got hundreds of computers which are usually under low load. And most have several gigabytes free.

All that’s needed is a server running on the public PCs that doesn’t interfere with normal use.

Wikipedia has some additional links on Distributed parallel fault tolerant file systems. Another free distributed fault tolerant filesystem is Hadoop, which seems to be vaguely based on GoogleFS.