Visions of Aestia

I thought I’d record my feelings on what I want to see in a Python IDE. For the moment, I’m quite happy to stick with GEdit, but I might look at pulling something together later.

For GUI development, I want integrated Glade support. Maybe the Gazpacho editor could be built on.

Some sort of GUI similar to jUnit/NUnit for all unit tests. I should be able to hit a button and get a green or red bar at any time, with a tree drill-down to individual suites and tests.

A Refactoring menu that leverages BicycleRepairMan to automate common refactorings. Highlight code, select “Extract Method", type method name, done.

A graphical, single-step debugger. The language has debugging capabilities built in, this should not be hard.

Syntax highlighting and decent indentation management (i.e., automatically adopt what the current file does). Code completion should be trivial to implement using class dictionaries.

Integration with Subversion (using pysvn) for source control commands. Having TRAC bug reports appear as TODO items is a cool extra.

Creating new projects should handle the usual open-source boilerplate (README, INSTALL, HACKING, ….) and allow selection of a license and default indentation policy.

Some sort of distutil magic would be good; especially for modules. Public modules intended to go into site-path versus private modules intended for a single application.

That’s all I really need. It’s not a huge feature list and one could leverage plenty of existing projects for most of the functionality. Like all good Python projects, it’s just about tying together good libraries.

I wandered pretty far off-topic in my last post, so let me add some more thoughts.

It is possible, through the addition of metadata about statements, to negate, change, or override existing statements. However, I do not believe there is a well-documented, carefully thought out consensus on how to do so.

This consensus needs to come about, and it needs to be a core part of RDF or OWL (probably the latter) so that it is widely supported by reasoners. In the next few years, there will be hordes of newcomers to this technology, and they all will be struggling with the same issues. If there is not a ready answer, they will declare RDF a failure and go back to their XML files with OO wrappers.

Here’s a couple minor proposals to start the ball rolling.

  John C Barstow

This is the opposite of rdf:Description. Instead of telling the parser to add the assertion, it instructs the parser to remove any such statement and ignore it in future.

  
          Comments (0)
        

In his post, Semantic Wave: When Do Assertions Become Facts?, Jamie Pitts struggles with some of the same issues I have been struggling with recently.

Jamie notes:

As time passes, the latest assertions about role will inevitably contradict previous assertions.

For some relationships, such as an individual’s role, the addition of a property indicating “effective dates” is an appropriate way of avoiding contradiction.
All individuals fulfill a role for limited time; that’s why we put dates on resumes. It’s entirely possible and desirable to reflect this in RDF.
As with the database, the “current” understanding is really an implicit query looking for statements that are effective today. Thankfully, it’s much easier to model statements about statements in RDF than in relational models.

It goes without saying that interpretations of reality are formed in the mind through an ongoing process of re-assessment. We qualitatively compare present impressions with recent impressions. Enough contradiction, and we form a new working state of understanding.

Well, this is really AI territory, isn’t it? An AI needs to recognize assertions that contradict its current knowledge base, decide whether to resolve the contradiction by throwing out the new or old assertion, and re-initialize its deduction/inference engine to recreate all derived knowledge.

Hmmm…let’s run with that for a minute (thinking out loud here).

Here’s an AI; it manages one or more knowledge bases in RDF/OWL and serves up answers to SPARQL queries, possibly formulated by some NLS parser.
It gathers information by spidering or exchanging RDF with other AIs. It reasons by tapping external deduction/inference engines.
One of the knowledge bases contains trust metrics, used to weight the new RDF statements.
A reasoner is set up to check the new information for internal consistency - if the information contradicts itself the source is presented a proof and metrics may be adjusted.
A reasoner then compares the new information with the one or more existing knowledge bases looking for contradictions. Multiple reasoners should be consulted.
If no contradictions, the new information is added. If contradictions are found, the stronger assertion is persists; strength depends on many metrics, including trustworthiness of original sources, degree of corroboration from other sources, metrics concerning number of other assertions affected, and so forth.
One or more reasoning daemons takes the new knowledge base and deduces as many new facts as possible. The strength of the underlying premises determines the strength of the new assertions.
A couple of things we can add - an imagination. Create random triples, then use a reasoner to look for contradictions or proofs. Add surviving assertions to the knowledge base. We can try less random things such as making assertions about superclasses or removing restrictions.
How about experimentation? Some sensors and motors, and now we can start adding experimentally derived facts to the knowledge base.

Of course, for Jamie’s example, he can accomplish what he wants simply by adding new statements. All that’s needed is a shift in thinking; you’re not making assertions about the current state of things, you’re making assertions about a date range that happens to include today (and possibly not making any assertions, yet, about the end of the date range). Now facts are not changing, you’re merely acquiring new facts.

Some of the tasks I want to accomplish with RDF, in no particular order.

Keep track of the relationships between characters in a novel, movie, or role-playing game. (FOAF?) Maybe I will finally figure out who shot Mr. Burns.

Create or query for NPCs with some stated constraints, such as “a level 4 character with the Quick Draw feat and at least 5 ranks in the Tumble skill.” (OWL or SPARQL) A good random character generator. No, really.

Represent the semantics of a snippet of Python code with OWL. Generate Python code from an OWL Full description (since both Python and OWL Full allow classes to be treated as instances). Because I am a geek.

Generate human-readable RPG rules from RDF. I can now find and eliminate contradictions in the rule sets before publication.

Write a reasoner that can play a card game like Rokugan, with each card and its rules represented in RDF. No longer do I have convince my wife to play.

Encode enough semantic meaning into a screenplay that I can change any detail about a character and have all dialogue and descriptions reflect this. This will of course displace the standard Hollywood script writer, especially when the program is smart enough to handle replacing a human character with a talking dog.

ongoing � More Patent Funnies

This is NOT funny. Google has just this month received a patent on “highlighting matches to search terms in retrieved documents".

How could this even happen? One of the criteria for a patent is supposed to be that an idea is non-obvious. There are plenty of RDF tools that could be considered to be covered by this.

There is no longer any justification, in my mind, for a 20-year patent (what business plan goes out more than 5 years, anyway?). And I’m seriously thinking of joining the camp that says all patents are worthless.

The point of a patent is that if you invent something, you, rather than some copycat, get to make money off of it. The problem is that in today’s world, you don’t - either you spend all your time and money in monitoring and litigation, or you use it as a weapon against competitors.

This patent should never have been granted. I personally had prior art in 1991, nine years before the patent was even filed. And I was still in high school at the time!

One of the issues I’m struggling with at the moment is the fact that OWL doesn’t really handle subclassing very completely. I’d be pleased to shown I am wrong about my assertions here.

In the OWL model I can:
- Add new properties
- Refine the domain or range of a property.

However, I cannot:
- Remove a property.
- Change the domain or range of a property to something completely different.

Frankly, these are not onerous restrictions. However, I think it’s important to remember that RDF is meant to be distributed; these restrictions make it difficult to code around errors or model poorly-defined domains.

If there is an error in a document, I have no standard way of using the definition sans error. Consider the following scenario.

animals.rdf

  ...
  
    
      
      
    
  

australia.rdf

Here, the first document encodes a common, if misleading, definition of a mammal. Mammals (usually) give birth to live young, and the original author mistakenly included this assumption in his ontology.

However, this definition is wrong. The platypus is a mammal that lays eggs. Clearly, the definition needs to be changed by removing the restriction, and if I in fact have control over both documents, this is easy to accomplish.
Thanks to the distributed nature of RDF, however, this may not be possible. What if I can’t correct the document or convince the author he is mistaken? I need a way to assert that the platypus is indeed a mammal, but an exceptional one that lays eggs instead of giving birth to live young (note that without cardinality restrictions I can say an animal does both).
The tack I would like to take is to define a special subclass of mammal, say egglayingMammals, that removes the restriction. But I don’t know of any way to do this short of defining my own, non-standard properties.

Now, the current fact is that most ontologies are currently being created by domain experts. But as RDF trickles down to the common developer, more and more ontologies are going to be hastily created without the input of domain experts, and will contain errors and contradictions that need to be coded around. I think we need a way to create definitions that lifts or ignores the restrictions laid down by a superclass. We need a way to assert that some parts of a definition or certain data must be ignored. We need a standard way to assert that something is wrong, or that a perceived contradiction can be ignored. It may be messy and inelegant, but frankly so is most code (and data) in the real world. Ever try to normalize address data?

Pushing String � Happy birthday to you

…when a song composed in 1893 is still under copyright in 2030. That’s 137 years, by my reckoning. Whatever happened to “limited duration"?

What’s really sad is that the current interpretation of the law prohibits derivative works, so even the oldest living composer can’t build upon it to create a new work.

ongoing - Testing Backward

Tim Bray shares a common mistake made while unit testing. Note that even if you don’t unit test, you can waste the same amount of time doing debugging a problem like this.

For the most part, I have been using a NotImplemented exception when stubbing since the COM days (they had an E_NOTIMPLEMENTED code, as I recall).

Four years ago today, I was married. Of course Ama and I had been in a committed relationship for several years prior to this event, but things still changed.

Not the things we feared might change - those continue to evolve at their normal rate. No, the things that changed were deeper in many ways.

My faith in Ama’s love became unbounded. In making such a public and premeditated pronouncement of her devotion to our lives together, she made it much harder to back out of that commitment.

In addition to the moral and spiritual obligations that we had already built between us, we also appended a variety of legal and social obligations that had nothing to do with our profound love for one another and everything to do with how other people viewed us. But still it had an effect, in that, in so much as can be measured, I became more responsible.

(Those who know me now may wonder at how I could ever have been less responsible - perhaps Ama will share.)

When I am upset, or tired, or finding it difficult to make it through the day, it is the thought of Ama waiting for me at home that empowers me. When I am stressed by work or money matters or any of the hundred of life’s annoyances, the memory of my beloved’s smile, or her touch, is enough to dispel my burdens.

True, we fight. True, we have sorely tested one another. It is not marriage that keeps us together, it is love. For all our travails, I dare not imagine life without Ama, and my faith in her love and talent and genuine beauty only deepens over time. I would not trade even the worst day of these four years for anything. It is all to be treasured, even the tears and the pain, because it is time spent with her.

It’s nice to see that Google is aware of and doing something about comment spam. I’m definitely upgrading my WordPress installation as soon as this is implemented.

One thing which consistently confuses me is the the fact the rdf:about and rdf:resource follow the usual rules for resolving relative URIs, but rdf:ID does not.

Specifically, as Ed Davies points out in his comment to Refactoring to RDF, step 1, a relative rdf:ID is always interpreted as an anchor within the current document.

This means that within the document “http://example.org/orders":

“http://example.org/customer#12″, being an absolute URI, is handled identically by rdf:ID, rdf:about, and rdf:resource.

The relative URI “customer#12″ is interpreted as “http://example.org/customer#12″ by rdf:about and rdf:resource, but as “http://example.org/orders#customer#12″ by rdf:ID.

This difference in interpretation of relative URIs extends to cases where xml:base is specified.

The best bet for me, personally, is to either always use rdf:about or to always use absolute URIs.

I’ve added some stronger comment spam tools, and optimistically re-enabled comments. Have fun.

Dave Beckett has looked over my RDF data and kindly chosen to add me to the list of semantic bloggers. This is very, very cool since I read Planet RDF on a daily basis.

I’ve been working with XML since the spec was released and have recently become an RDF convert. For the longest time I was completely put off by both the unreadability of the specs and the hideous, hideous serialization format. Thankfully, OWL came along with a readable document that built on RDF, and I found a little python module called sparta that made the scales fall from my eyes.

My version of the RDF elephant is quite simple - it is a distributed form of XML. I know that’s an oversimplification on many levels, but it also makes it really easy to make the transition from producing pure XML to producing ‘dumb’ RDF - that is, pure data just below the semantic layer. Thanks to its distributed nature, some of you smart folks can produce ontologies, triple stores, and inference engines.

Anyway, for the next few weeks I’ll keep working on my series on refactoring XML to RDF.

Step 3 of our refactoring is moving from an XML parser to an RDF parser. This can get a bit tricky, so we’re going to a make a few assumptions to avoid outlining every possible scenario.

Let’s assume that your load/save logic is reasonably isolated, and looks something like this:

class order:
    def load(self, node):
        self.id = int(node.id)
        self.customer = customer(node.customer)
        self.product = [product(p) for p in node.product] # a list of products

Here we’re relying on something vaguely-DOMish to traverse down the XML tree and creating objects that correspond to the various elements and attributes we encounter. Type inference could easily happen if some sort of schema description existed.

Now, RDF parsers don’t use the DOM as such, because they may be pulling together information from multiple documents. Instead, most parsers use the triple store as their interface.
Conceptually, this is quite simple. Each object we’re going to create has an rdf:ID, and it may be serialized across multiple documents (using rdf:about to add to the original XML). The fields we are serializing are either references to other objects (rdf:resource links) or simple types (element/attribute values).
All you need to know for this step is that you can get the fields values by issuing a query - the rest will attend to itself. Since we no longer have a context node, the id will need to be passed in to our load function.

class order:
    def load(self, store, id):
        self.id = id #this will be the rdf id, so it is a URI like "order#17" instead of an int
        self.customer = store.query(id, "order.schema#customer", None)
        self.product = store.query(id, "order.schema#product", None) # a list of products

See how similar this is? Instead of assuming that the interesting elements/attributes are children of the current node, we ask the RDF parser for the children of the current node. This is why RDF can be distributed - the parser hides the fact that some of the data may once have lived in another document.
Now, I have deliberately left calling the object constructors to the store.query( ) method. Most RDF stores can use schema or type information and do the right thing. However, some stores cannot create objects and only return the rdf:ID of the children we are interested in.
In this case, the code becomes:

class order:
    def load(self, store, id):
        self.id = id #this will be the rdf id, so it is a URI like "order#17" instead of an int
        self.customer = customer(store.query(id, "order.schema#customer", None))
        self.product = [product(p) for p in store.query(id, "order.schema#product", None)] # a list of products

Which is even more like our original sample.

One final note - some RDF parsers may require your document’s root element to be rdf:RDF. Live with it or find a more liberal parser.

In part four we’ll get into that type information deferred from this step, show a helper class to create objects of the correct type, and start looking at the more interesting things we can do now that we are RDF-enabled.

You might want to review Part 1 before proceeding.

Our document fragment last looked like this:

Remember, this is a fragment. It assumes there is a root element declaring the RDF namspace.

Step 2 of our refactoring is to add RDF-style namespaces. Technically we do not need to do this, and there are plenty of existing RDF namespaces you might want to use, including FOAF, RSS, and Dublin Core.

An RDF-style namespace is just like any other XML namespace, except by convention it ends with a hash(#) sign or slash(/).

Just in case it hasn’t clicked, the reason for this convention is to allow us to write RDF that describes the elements. When we combine the namespace and local name, we get an RDF ID - now we can write our schema in RDF!

You’ll note both styles of namespace here - the RDF Schema namespace ends with a hash sign, while the FOAF namespace (http://xmlns.com/foaf/0.1/) ends with a slash. This example says that the customer element has type foaf:Person.

Actually specifying and using type information is something we’ll cover in step 3; for now the important thing is that we’ve added a namespace. Any existing serialization code will need to be updated to handle the namespace. Here’s our fleshed out sample showing the root element.

To recap:

• Step 0: Make sure your XML parser understands namespaces
• Step 1: Replace any existing ID values in your XML with RDF-specific IDs. That is, the value becomes a URI and the attribute becomes rdf:ID, rdf:resource, or rdf:about.
• Step 2: Add RDF-style namespaces. The namespace URIs should end in a hash(#) or slash(/). All elements and attributes should be in an RDF-style namespace.

This morning there were over 100 spam comments sitting in the moderation queue. I’ve disabled comments until I can install more powerful anti-spam measures.

I’m still allowing trackbacks at the moment, so that’s the only way to leave comments.

Understanding XML: XML in the Crystal Ball: Publishing, Syndication, Marketing

This is a really insightful post on the role of XML in web publishing. I need to mull things over before responding, but I think this is worth reading if you have any interest in the publishing field.

Everyone is blogging about this, but nobody seems to be linking to the actual list of patents - so here it is.

500 patents

The really interesting thing is the way the license is phrased; open source developers can use them without issue, and proprietary developers can use them so long as they do not sue open source developers.
In other words, we can all share IBM’s toys, but bullying someone means you have your toys taken away.

Understanding XML: XML In the Crystal Ball: XForms and the Revitalized Client

Not surprisingly, I agree with everything that Kurt Cagle is saying in this post.

One of the things I have always hated about web development is the need to create masses of JavaScript just to enforce a handful of constraints.
XForms had made it much more natural to generate user interfaces and gets rid of the need for much of the current layout code and almost all the client-side code.

Even now, I use XForms on the client side and use XSLT to generate (admittedly simple) forms for the browser. Being able to pass XForms to the client will eliminate a whole lot of code on both the server and the client, simplifying everything.

I can’t wait.

I’ve been using sparta for my RDF serialization lately, and have come up with a useful patch. Turns out a frequent use case (for me, anyway) is getting all objects of a specific type.

I’ve found the following addition to ThingFactory does exactly what I want it to do:

def instancesOf(self, typeUri):
    return [self(s) in self.store.subjects(TYPE, URI(typeUri))]

What it’s doing is getting all objects in the store that have the given rdf:type. I use this all the time when hooking things up to the UI.

My usage looks like this:

def loadPeople(self, store):
    self.create = ThingFactory(store)
    people = self.create.instancesOf(example_person)

I’ve changed the template to generate an RSS 1.0 feed by default instead of the RSS2 or 0.92 feeds. In theory nobody will notice.

This is prerequisite to getting syndicated on some Planet feeds.

Today was Cecily’s first Christmas. She really, really enjoyed herself opening her presents. She started going “ooooh” every time she opened a new present, and was very excited over most of them.

All after noon she’s been playing with her new toys and just having a ball. I was really happy just to see her enjoy herself so much.

She also got to have some fruit cake and learned to say “uh-oh” when she knocked down a block tower. Her maternal grandparents got to see her open the presents on Webcam and were very pleased to see her having fun.

It’s hard to believe thar it’s been less than a year since she was born. Her personality is forming up very nicely. A little stubborn, but warm and loving. She loves books, laughs all the time, is bright as a button, and just seems to enjoy life. Her favorite food to date is cheese and she prefers plain water to juice. She’s going through the terrible twos a year early but speaks wonderfully. Her vocabulary is growing by leaps and bounds and the new toys and books will grow it even more.

I suspect we got very lucky. She’s a low-maintenance child and if we don’t make any major mistakes in the next couple of years she will be a complete angel when she gets older. I think fatherhood suits me - because I’ve rarely been happier than I have been this year.

CD Baby: JOHNNY “BOWTIE” BARSTOW: A Bowtie Christmas And More - hear and buy it at CD BABY.

Out for one day and has already sold out (it was in stock last night)! AND a five-star review.

So I don’t forget about this later.

So, here’s the problem that has been plaguing our Linux box. Thanks to the current state of things in the X Windows (you know, the GUI) world, there are any number of things that can go wrong.

First of all, NVidia has split their driver into two pieces; there’s a kernel bit and an X-specific bit. If the two get out of sync, X will not start. It’s very easy to diagnose, but still a problem. Why does it need to be in two pieces?

Secondly, although all the other parts of the system support hotplugging, X does not. It only knows about things in its config file, and panics if it can’t find something.

I have a USB tablet. If I enable it in the X config file, X will refuse to start if it is unplugged at boot time. If I disable it in the X config file, I can’t use it because X does not recognise it when it is plugged in.

In other words, X is very, very brittle. It breaks *way* too easily in very common configurations and makes upgrades a hassle. It’s nice that I no longer have to manually set the monitor refresh rates, but honestly it should just work.

Now, the folks who maintain the X11 tree are not nice people and have long resisted any important improvements. However, the X.org people have a much more welcoming attitude and have made huge strides in the last couple of releases, including a modular version of the code and a compositing manager that enables lots of cool effects.

So, my position is that the single most important feature right now is getting hotplug working. I should no longer have to think about my keyboards, mice, tablets, or monitors; if they’re plugged in and supported, they should just work in my preferred environment. I’ll obviously have to join their mailing list and get on their case; but in this day and age, I shouldn’t have to.

: Food for thought - brought to us by the legendary Oleg Tkachenko

This is absolutely the most brilliant suggestion ever. If Microsoft were to do this I might even start using their XSLT processor again.

I have mountains of code that would see an immediate upgrade and vast improvement if I wasn’t constrained by the lack of 1.1 support.

I was just saying the other day that the only thing holding me back from large-scale XSLT apps is the lack of dyn:evaluate() and the result tree fragment problem.

In fact, maybe I’ll start looking at the XSLT code in Mono right now.

IBM Redbooks | Linux Client Migration Cookbook A Practical Planning and Implementation Guide for Migrating to Desktop Linux

Finally, a migration guide. Now I have something to complement my personal experience.

My music CD was released to manufacturing today. Should be on sale any day now.

At least it’s out before Christmas proper, though it may be difficult to get copies in time for the holidays.

Coming Soon! - Latest News

I heard rumours about this the last year or two; unfortunately the loss of Stephen Biggs (Dr. Franklin) caused a script rewrite.

Looks like the new script has finally been approved and filming can begin!

OK, let’s say you’ve decided to take the plunge and switch from plain XML to the distributed kind you get with RDF. How are you going to get there?

Step 0: Make sure your XML parser understands namespaces. You’re going to be needing them.

The first refactoring should be pretty easy. You need to replace any existing ID values in your XML with RDF-specific IDs.
Let’s look at an example snippet:





Probably this XML comes from a database somewhere. Doesn’t really matter. The thing to recognise here is that the “id” attribute is actually being used as both an anchor and a reference.

Pass one, we replace the anchors.





Remember, RDF just uses the ID value as a unique key. It doesn’t have to point to a real document.

In pass two, we replace the references.





We also have to update any existing XML parsing we do to use the new attribute values instead of the old ones, but that should be straightfoward.

UPDATE: Fixed broken example tags. Yeesh - and the characters WordPress ate.
UPDATE (27-Dec-2004): Fixed embarrassing typo in response to Dave’s comment below.

Once you understand that RDF is really just a distributed form of XML (see RDF/OWL == XML/XSLT, part 1 if needed), you’ll probably want to start taking advantage of it. Unfortunately, most of the existing tools seem to be written by AI specialists.

Dumb RDF is the kind most of us actually want to write. We don’t want to bother about transitive properties, triples, or inductive logic. All we really want is the ability to split our XML blocks across multiple files and magically piece it together. The other stuff is cool, but utterly irrelevant to most of us at this stage.

Examples of Dumb RDF includes Dublin Core (for tagging documents), FOAF (for tagging people), and RSS (for tagging syndicated content). All these examples involve some fairly simple XML that doesn’t require any special knowledge. Notice how popular these formats are.

Smart RDF is where we get into topic maps, ontologies, triples, and other complicated areas. This is where the AI people add all sorts of tags to constrain relationships, definitions, and carefully-defined vocabularies. Smart RDF can deduce that my father’s brother’s only brother’s daughter is my sister, is female, and has only one paternal uncle.

Dumb RDF is just data. Everybody can undertand it and generate it. This is where most of us will always want to be. But Smart RDF is where the active practitioners are. That’s why it seems so complicated and unapproachable.

You know what? That division is just fine, because RDF is distributed. You and I can go off and write Dumb RDF, W3C implementors can write Smart RDF, and we never have to know about each other. An RDF parser that stumbles across Smart RDF will suddenly get smarter and be able to answer more questions, but it still works if it sticks to Dumb RDF.

Animal Planet is going to be airing a segment on dragons. On the one hand, as an avid role-player, I certainly applaud any documentary that approaches one of my favorite creatures.

http://animal.discovery.com/convergence/dragons/dragons.html

On the other hand, I can’t help but worry about the general state of science programming on television. This feels very much like all those pseudo-documentaries about mummies and UFOs that get constant air time. No real substantial debate, mostly speculation, and constant repetition of key themes with little or no rigourous review of challenge.

In other words, pseudo-science instead of real science. Sure, “Scientific American Presents” and “Nova” present real science, but you’ll notice they get little traction against the huge volumes of rubbish being pumped out. Not a good trend at all.

Well, it was a nearly six-hour queue to get it, but my passport has been stamped to allow me to continue to work in this country through till February. Hopefully we will hear about our residence application by then.

Ama, however, gets to have me drop hers in the drop box instead of waiting for hours, because she was smarter than me.

Here are some tips on getting HL2 installed on Linux.

1 - You need Cedega 4.2 from Transgaming. Standard WINE won’t cut it because of the CD protection enforced by the publisher.

2 - HL2 will install into the Steam directory. I had to reinstall twice because of this; remember that installers don’t understand symlinks. I ended up making an entry in my config file that pointed a Windows drive to a big partition.

3 - The CD-based installer locks the drive, preventing you from swapping disks (at least on some machines, may depend on your CDROM model). After several false starts, I copied CD1 to the hard drive and ran setup from there. It still pulled everything off the CD, but I was able to swap discs without a problem.

4 - The whole registration process is a pain. Be prepared for some very long waits and a few failures. I understand that after the content is decrypted there is a way to play in offline mode, but dang if I can find it.

5 - There appear to be problems with the 2.6.9 kernel. Be prepared to roll back to 2.6.8 or forward to 2.6.10 if necessary.

Number of installs before success: 6. Not a stellar success story. However, it *did* work in the end, which is the most important bit.

Of course, the machine did not reboot successfully after running the game, but I’m fairly certain that’s because the nvidia driver needs updating.

Ama came downtown and stood in line with me for two hours so we could get our visas extended. We were told to come back early the next morning in order to be seen by an immigration officer.

I’m not happy. It would have taken them two minutes, all our info is already on file. I’ll get happier when you can file for an extension online; I’m sure most (80%) such applications can be granted immediately with a very small amount of work.

This morning Cecily added the word “button” to her vocabulary. I mentioned this to Ama, who asked her to say it for her.

Cecily pointed to one on my shirt and said “button” clear as a bell. Ama’s jaw dropped - wasn’t expecting that, clearly. The expression on her face was priceless.

Sometimes, when I’m working with XML I need to change vocabularies. That’s why we invented XSLT, so that I can take XML in one flavor, modify it a bit, and get out some other flavor. Probably the most common transformation is {your favourite XML variant} to XHTML.

When we’re doing transforms, what we’re really doing is exploring the relationships between chunks of XML, mostly with XPath. So we discover that “relatives/uncle” in my example is the same as “relation[type=’uncle’]” in your example, and we write some transforms to convert back and forth.

XSLT lets me take the things you write in XML and turn it into XML that I understand. So instead of rewriting my program to recognize “foaf:name", I can write an XSLT filter that turns it into “person/name". I can do lots of other things with it, but that’s the core use case.






OWL lets me do the same thing on an RDF level. In other words, take some XML you understand and map it to some XML I understand.







25




Pointing our transform at either of these documents is not going to produce results, because the color attribute is not actually defined on the wine element. OWL, however, builds on the distributed nature of RDF and can easily output the WhiteWine element.

I know I’ve left a lot out, but hopefully this will help someone else start grokking the Semantic Web.

Once upon a time, you used to have to explain XML to a group of IT people who had never heard of it. You’d give a little speech starting “XML is just like HTML except….", followed by the five or six key points about XML. It was of course a drastic oversimplification and lots of details were glossed over, but everyone understood the basic concepts.

This is my attempt at a similar stab at getting everyone to understand RDF/OWL.

RDF and OWL are just like XML and XSLT. Let me illustrate.

A chunk of XML describing a person might look like this:


Clifford


If you wanted to link to this chunk of XML, you would use something like:








Cliff
United States



As far as any RDF application is concerned, this is exactly the same as if I edited the original document to look like this:


Clifford


What the RDF parser is doing (conceptually) is following the link to get the original XML, then adding anything contained in the description block to get the final XML it ends up showing you. I could do this manually in XSLT by writing a transform, at least for simple cases.

There is only one other thing you need to know about RDF.

Most RDF browsers don’t actually care if a document you link to exists; they just won’t be able to show you much information. If example.org/family.xml is deleted, the browser will only show my uncle’s nickname and country. But that’s fine, it can still combine any other description blocks it finds that link to him. From an RDF perspective, the URL is just a unique identifier, like a database key.

The bit about adding description blocks together is really key. When I don’t have access or permission to modify an XML document, I can create a description block so that it appears (to an RDF browser) that I’ve made the changes anyway.

On to OWL in my next post.

Sparta is a small python library I came across on Planet RDF. Basically it parses RDF into Python objects.

It’s pretty simple, gets the job done and will require very little work to serialize things the way I want to.

The main thing I need is an instances collection for rdf.type and owl.class objects. I would think this a fairly obvious starting point for a lot of application processing - get me all the person instances so I can display them in a contact book, for example.

This should be trivial to implement as a predefined query against the underlying triple store; on a side journey some of the owl relationships, such as subclasses, may need to be addressed.

Finally, mapping an RDF type to a specific, preexisting Python type is a must for decent refactoring of existing code. I need to investigate Sparta a bit more to understand if this is currently possible.

In addition to today’s unaided steps, Cecily walked twice while holding my hand. When she was trying to get into the icebox, I took her hand and, surprisingly, led her over to her toybox. She quite happily walked all the way over.

Then we had to do it all over again so Mommy could capture it on camera.

Center for Social Media: Events

Jon Else, series producer and cinematographer for Henry Hampton’s Eyes on the Prize, noted, “Eyes on the Prize is no longer available for purchase. It is virtually the only audio-visual purveyor of the history of the civil rights movement in America. What happened was the series was done cheaply and had a terrible fundraising problem. There was barely enough to purchase a minimum five year rights on the archive heavy footage. Each episode in the series is 50% archival. And most of the archive shots are derived from commercial sources. The five year licenses expired and the company that made the film also expired. And now we have a situation where we have this series for which there are no rights licenses. Eyes on the Prize cannot be broadcast on any TV venue anywhere, nor can it be sold. Whatever threadbare copies are available in universities around the country are the only ones that will ever exist. It will cost $500,000 to re-up all the rights for this film. This is a piece of landmark TV history that has vanished.”

I remember this from my younger days. Here is something I desperately want my child to see, to understand, and it is not available to show her and may never be. This is precisely why I have such a problem with the permissions culture springing up the way it has. I mean, think about it. Nothing from my childhood - or even my parent’s childhood; in some cases my grandparent’s childhood - is available for drawing upon creatively; it all must be cleared by lawyers and rights holders. No wonder television is a cultural wasteland.

Guardian Unlimited | Special reports | You asked for my evidence, Mr Ambassador. Here it is

Here’s a open letter to the US Ambassador from Noami Klein, citing evidence that the United States is systematically eliminating those who dare to report on the number of civilian casualties in Iraq.

These are the first actions of a military dictatorship - silence the opposition. No wonder so much hatred is directed towards America. Next comes accusations of collaboration and conspiracy against domestic protesters (who are already herded in to barbed-wire “free-speech” zones).

EN World - Morrus’ D&D / d20 News & Reviews Site - Scenario Writers Needed

Reminder to myself to start keeping track of our B5 campaign in writing. 30,000 words by March?

: Is everyone EXCEPT me using Python for XML/XSLT development?

M. David Peterson was wondering why people are using Python for XML development. I left the following as a comment on his blog; here it is for the rest of you too lazy to read his comments section.

First point - there’s nothing special about processing XML/XSLT from Python versus another language. Most likely you’re still going to be using either DOM or SAX to process your data.

There are three special features of Python that make it attractive in general.

1) Lists, dictionaries, tuples, and sets are native data types. Once you realize how many lines of code you spend creating and looping through collections in other languages, you’ll really, really appreciate this feature. This is what brought me into the language.

Most Python XML libraries allow you to write things like:

attributeNames = [a.name for a in element.attributes()]

Actually, they’d let you write something more elegant and interesting, but the point is that identical code in, say, C# would be five or six lines. The result here is an instance of the standard list class.

2) It is a terse but readable language. This is very important. The line of code above is typical and should be easy to understand no matter what your background. This makes it easy to debug and maintain.

A lot of people use it for prototyping. I have a fairly complex GUI application I’ve written that is less than 1,000 lines of code. An earlier version in C# was over 8,000 lines and had less than half the functionality.

3) Classes are first-class citizens. Adding a custom property to an object dynamically in other languages is several lines of not-always-trivial reflection code. In Python, I can write:

attributeNames.originalElement = element

It’s the combination of these three points that make python interesting. Being able to create classes on the fly as XML is read in and write code that uses those classes with no special steps is, I think, one of the big attractions. Add in the fact that all that traversal of nodes can be done using simple, built-in collection types and that’s icing on the cake.

For the record, Dive Into Python is great resource for those new to the language, and it includes a chapter on XML.

Here’s the revamped step 3 screen, selecting a class. This one shows the traits and description both expanded.

I’m unsure of the best way to present the description, preqs, and class features in a manner consistent with the HIG. One idea I’m toying with is to just show the traits from the current class level and have an “Information” button that brings up a simple, read-only popup window (either a rich text or HTML widget) with a close button.

You’ll note the warning icon next to the giant racial level; this is how any class with unmet prequisites would be displayed. There will be a configuration option to simply not list unavailable classes, but many (most?) people like to plan ahead for prestige classes and will want to examine the features and preqs.

D20 Shakespeare

Damn and double damn! I was working on this! Well, maybe I can see about doing one of the other plays for them. Midsummer’s Night Dream, perhaps?

Here we go with the second screen from the character generator; this is the revised “select race” step.

This has an effect on the ability scores, which is currently not shown. The “Description” area collapses down in the same fashion as the “Racial Traits” area, under the assumption that anyone who has been through this screen before will largely ignore it.

The clan/bloodline combo box, currently disabled, would be for selecting a clan, bloodline, or subrace as appropriate for a given race and campaign setting.

Just had an IM conversation with Ama that has improved my mood considerably. It only goes to underscore the importance of communication in a relationship.

She deleted her posts from this morning - shame. I could have used them as a reminder of what she is going through when I’m not there.

I’m leaving mine up - it’s a little painful to leave it out there, but it’ll remind her of what I’m going through when I’m upset.

Essays 1743: font by John Stracke

This is a realy nice role-playing font. I might want to play with using it as the body font for the Aestia book.

Well, there are good days and there are bad days. The good days are far more numerous than the bad days, but the bad days are still awful.

WARNING: excessive negativity in this post. I will try to balance it with a positive post when my mood lightens. This is just how I feel on my bad days, not how I feel all the time.

On the bad days:
When I am sick, I am told that it’s all in my head or that I’m trying to upstage someone who is really sick.
When I am depressed, I am told to get over it. The words “pity party” have been used.
When I do something stupid - which happens quite often - I get dressed down in front of Cecily. This morning she was looking back and forth between me and Mommy trying to figure out what was going on.

I work an eight-hour day, come home and spend two hours watching my daughter; I also watch her all day on the weekends. I come straight home after work and do not go out by myself on the weekends. If I did not run my games I would not have a social life.

I also spend up to 10 hours a week maintaining and expanding my computing skills so I can continue to get the best paying consulting gigs. Most of this is through technical reading but I also have programming and 300 e-mail messages a day from various mailing lists.

I’ve never been treated like a king nor have I ever asked that - and I am very aware of my personal failings. I constantly promise to spend an hour working on chores and frequently do not follow through. I sleep in later than I should, and cannot do the dishes, laundry, or vacuuming correctly. I am not even capable of feeding Cecily without major incident.

I get depressed, I guess, because I want a word of encouragement or sympathy now and again but do things so poorly and inconsistently at home that instead I constantly frustrate Ama. When she frowns, it feels like a bottomless pit opens up beneath my feet, and when she is angry all the color runs out of my life. Here is the most wonderful, beautiful creature I have ever met and yet I do nothing but upset her. All I ever want to do with my life is make her smile, and yet I cannot do the smallest things that would make her happy.

Maybe I’ll feel better after lunch.

Always put your dice away after a game if you have little children.

If you don’t, you’ll have to miss a day of work because the little one has been taken down to ER.

Cecily stood for several minutes at a time today. I was busy preparing her dinner and she was standing next to her little scooter beeping the horn. She was clearly balancing herself - as opposed to leaning on the scooter - but it didn;t really register.

That is, until she clapped. She has an endearing habit of applauding when she does something she is proud of or is especially excited. The fact that she did so without a second thought and without any special effort to keep her balance drove home just how close she is to actually walking on her own.

Any day now…

Here is the first screenshot from the character generator. This is the screen for rolling and assigning ability scores.

This is currently set to the standard 4d6, drop 1 method of rolling. The dropped die is shown here grayed out. The combo boxes can be used to quickly swap scores around.

The plan is that you hit “Roll” until you have some nice scores, then use the combo boxes to put scores where you like. One or two swaps should be fine for most people.

Of course, the DM will be able to restrict the rolling methods, number of rolls, and range of scores. By range, I mean that the DM will be able to set minimum and maximum point buy equivalents so that players will not get excessively high or low combinations.

Last night’s work eliminated 200 lines of buggy code, replacing it with 20 lines of far nicer code.

In addition, I made significant progress towards GNOME HIG 2.0 compliance. The abilities screen has been overhauled, and the ‘add equipment’ created.

I also made the decision to turn the “new character” process into a wizard. It really fits best as we have a standard, step-by-step process for character creation, but for some reason it…irks me. No concrete reason.

So today Ama calls me from the ER - never a good thing. Apparently Cecily nearly choked to death on an unknown substance - she actually stopped breathing for about 30 seconds.

Luckily she’s fine, and none the worse for wear. An x-ray didn’t turn anything obvious up, but we suspect it was paper.

I notice that there is no real, solid guide to using Glade to meet the HIG. I mean, the guidelines themselves have examples embedded, but I think there needs to be a solid, start-to-finish guide showing all the guidelines mentioned.

It would be especially nice if it gave tips on what needs to be done in code (such as making labels the same size) versus what can be done purely through layout.

It’s always nice to see participation up in a shared initiative like the wiki. Hopefully the trend will continue.

The European Union’s foreign policy chief, Javier Solana, said, “We will not accept elections that are fraudulent.”

That’s the Ukraine they’re talking about, not the USA.

I wish I had a direct quote from Colin Powell, but here’s the essence (from the New York Times):

Western election observers, and Western leaders, have been unequivocally critical of Sunday’s election here, saying the extensive documentation of organized fraud and the abuse of state powers to the prime minister’s advantage have tainted its official result and called into question its validity.

I’d say we have pretty extensive documentation of organized fraud and the abuse of state powers in the US election, yet for some reason Western leaders are just accepting the official results.

Writing PyGTK applications in a visual way

This tutorial is a good primer for anyone contemplating application development. Just remember to follow the GNOME HIG, which of course the tutorial doesn’t.

The bit where the write a fully functional graphical web browser in less than 100 lines should get you thinking about Python seriously.

The so-called safedisc protection that publishers use is supposed to decrease piracy. Except, as most of you know, when it increases it.

We just spent $100 on a new game, and it flat-out doesn’t work with our CD drive. Why? Safedisc prevents the game from running. So now I’m looking for a no-CD crack that will work with the version I bought so my wife can play the game. And if I find a reliable source, I just might become a pirate.

I mean, why play $100 to buy a game I can’t play, when I can get a free copy that actually works? Don’t the publishers even consider the long-term satisfaction of their customers? Yes, that’s rhetorical.

Yesterday was Cecily’s first visit to the zoo, and she absolutely loved it. She should have been sleepy (missed a nap) but for most of the visit was wide awake and fascinated.

I think the highlights for her were the meerkats, the pelicans, the monkeys, and the ducks (she loves ducks). She also got to see giraffes, a variety of colorful birds, and an otter.

iStockphoto.com - royalty free stock photography community
This site has an interesting model; you (as a photographer) upload images for others to download and use. They pay 50 cents per image downloaded, and you get a 10 cent credit.

So, if you submit a picture, you get a ‘free’ image for every five people that download it. You can cash out your credits if the amount earned passes $100 (that’s what, 1000 downloads? Not bad.)

I’ve decided to prepare a one-off Babylon 5 adventure for tomorrow’s game. I really need to get familiar with the starship combat rules if I’m ever going to run a campaign, and a one-off seems the obvious way to playtest the rules.

Of course, we have the option of just rolling up characters for a ’stand-by’ campaign, which will probably be a B5 series of arcs.

Just noticed this announcement of the CWM release via Planet RDF.

Since I just spent some time researching Python RDF parsers, I thought this might be worth a look. Basically you can feed it RDF or OWL, optionally let it deduce some relationships and then query it for interesting information.

It’s pretty simple to use (I looked at an earlier version last year) . I’ll have to do some testing to figure out just how usable it is now.

The US Congress is planning to pass a bill that makes skipping commercials illegal.

This is what you get when to law is written by commercial entities rather than individuals. I can’t imagine any parent wanting this bill to pass; isn’t it hard enough to handle advertising aimed at children?

Details can be found in a Wired article.

I wanted to write this down while I was thinking about it.

FOAF is supposed to capture relationships between people as RDF. You could easily use it to capture relationships between characters in a campaign setting.

Imagine if a character generator created FOAF entries as your campaign evolved? What a great DM tool!

A few weeks ago I had an epiphany regarding character generators.

See, the problem with serializing rules as XML is that RPG rules are rather loosely defined. Lots and lots of rules are written by reference to other rules (the same as lesser dominate, with a longer duration) or as an exception to the usual rules. Many rules create new stats or categories.

What’s more, lists of rules that fit certain categories often gain new members when a book is published, such as the list of bonus fighter feats that just gets longer and longer with every feat book.

So attempting to define a solid XML schema seems more and more a pipe dream the more books you own. What we really need is a way to extend rule definitions in a haphazard, reasonable way.

Enter RDF. With RDF, I’m just making short, disconnected assertions about a rule.

• “Cleave is a feat.”
• “Cleave is a fighter bonus feat.”
• “Cleave is a prerequiste for Improved Cleave.”
• “Cleave requires Power Attack".

These sentences don’t have to be in the same book and some of these relationships can be inferred. This is really cool when you start thinking about all those wonky rule definitions.

• “Sea elves are elves.”
• “Sea elves have the racial trait water breathing.”
• “Sea elves are not proficient in bows.”
• “Subrace traits override standard racial traits.”

A character generator powered by RDF can automatically infer all the usual rules about elves, then add the two new rules. The last statement is necessary to resolve the contradiction (elves are proficient in bows, but sea elves are not).

Thinking about rules like this suddenly makes a lot of sense. And I think it’s key to doing things right in the long term.

A small selection of notes from around the web, with an attempt to highlight XML-related news.

Mono 1.0.4 is released.
This is mainly a bug fix release; the only notable bug fixed plugs a major memory leak in ASP.NET code.

Mono 1.1.2 (development branch) is released.
The compiler now supports anonymous methods. “Today Mono 1.1.2’s C# compiler supports anonymous methods, iterators, partial classes, static classes and inline warning control from the 2.0 specification. Generics are supported as well on the branched `gmcs’ compiler (included).”
It also includes the XQuery and ObjectSpaces support dropped by Microsoft.

NUnit 2.2.1 released.
This is mainly a bug fix release (not a full release!) Notable changes include a source code reorganization, making the test runners into DLLs to allow other projects to reuse them, and a fix to allow for better compatibility with the VS 2005 debugger.

Docbook v4.4 CR2 is out. 4.4 will probably be the last release before 5.0 is out; 5.0 will be based on RELAX NG instead of DTDs.

http://www.rdfdata.org/ - More and more sites are making RDF available, and not just as RSS. The RDFData site is collecting links to data sets and web services providers of RDF. Notable additions to the collection include Metapihi (50,000 New Zealand images with Dublin Core metadata), the 2001 CIA World Fact Book, and the DAML airport gateway.

Redland, the RDF application framework now has C# bindings.

SPARQL Query Language for RDF looks a little bit like SQL and appears to be very approachable. The W3C has just released a working draft;Redland has already added support for it.

Cornell Law School’s Legal Information Institute has announced the release of a new online edition of the United States Code, including all the Federal law passed by Congress currently in force. For the first time, the project team is also releasing the underlying XML version as a dataset for use in research.

Schematron is now a final Committee Draft. It is under review by the various national bodies and is expected to be the final version.

The XSLT standard library has released version 1.2.1. The library contains 100% XSLT templates that can be called to handle string, math, date, and URI processing. This release is a bugfix release.

The first public working draft of XForms 1.1 has been published. The current version shows greater integration with SOAP and XML Schema; email addresses and credit card numbers are now datatypes.

I think one of the hallmarks of a good DM is the ability to wing it gracefully. Reading the ENWorld boards has got me thinking I’m getting good at it.

The +/-2 rule for modifiers is one of the best rules of thumb I ever came across. When in doubt, just add a bonus or penalty of +2 or -2 to account for oddball situations.

Well, the tests are real, it’s the objects that are mocked.

One of the problems I face when I introduce unit testing into a project that hasn’t made use of them is the incredible reliance on external sources. The project I’m on at the moment relies heavily on a (flaky) CMS to serve up most of the content we’re processing. Due to the unreliablity of the CMS, tests were failing every other run.

Using the Dynamic Mocks from NUnit 2.2 helped here; by using mock objects in place of the actual COM objects during testing, I had repeatable tests. Eventually the CMS was upgraded, but the ability to control the return values means we kept the mocks.

I have to use C# in my day job - and the amount of useless code I find myself writing is incredible. Half the time I find myself casting or writing typesafe wrappers. The other half I find myself rewriting and reinventing things I did 10 years ago, just in a new language.

If it weren’t for NUnit and NAnt I couldn’t stand this language.

As I continue to move spells from wiki 1 to wiki 2, I’m struck by how many of them have “hidden” material costs. The Arcana Unearthed design meant that it was the caster rather than the spell that dictated which components were necessary to cast a spell; however it appears that many spells mention costly components in their descriptions.

I’m tempted to rectify that, but in many cases I’m sure the designer was trying to balance things. Maybe I’ll just tamp down the power of a few of them as I remove the component cost.

Wordpress doesn’t have an obvious way to change the orginal author of a post. Which is a shame, since I meant that last post to be credited to me, not the site admin.

Looks like more research for me. *sigh*

Thanks to the handy Color Scheme Generator, I actually had the ability to make this page look reasonably nice.

What I especially appreciate about this generator is the ability to check color schemes against various degrees of color-blindness. The fashion-challenged everywhere thank the writer of this little tool.

In less than 48 hours this blog started accumulating comment spam. Easily taken care of, thanks to Wordpress configuration options, but annoying nonetheless.

The thing that was really amusing was that all the comments were quotes from the Communist Manifesto, with the spam link in the signature. Of course, now I have to install the Comment Moderation Plugin, but it’s a small price to pay for peace of mind.

It’s amazing the sheer number of spells I’ve already typed in.
Currently, I’ve moved about 60 spells from the old wiki to the new one, and I’m not even done with the letter C. How many spells, really, do you need?

Maybe I should start looking at alternate spell systems, like Elements of Magic. On the other hand, the system right now is fairly nuanced. Too nuanced? Hard to say.

(14:47:28) starkeeperlass: um. Like two sentences… yeah that will get lots of attention (:|
(14:47:55) jbowtie: You want longer posts, you make them.
(14:48:01) starkeeperlass: I got her to eat ramen noodles and cottage cheese for lunch, and now these marmite toast sticks
(14:48:03) jbowtie: I’ve done my duty.
(14:48:18) starkeeperlass: honestly. For such a proud father you dont do very much to brag about her
(14:48:28) jbowtie: I am a man of few words.
(14:48:34) starkeeperlass: this is great.. she’s chewing it and everything, not a single choke

Cecily tried Marmite for the first time today. She likes it.

More proof that moving to NZ was a good idea.

There we go. I’ve installed and configured a blog.

And there was much rejoicing.