Upcoming ACM Talk

I’m giving a talk to the Chicago ACM next month on the 11th at the Chicago Loop campus. They have updated their page to have the current information. The topic is "Domain Specific Languages" , loosely based on my DDJ article.

From the talk abstract:

"Within organizations, software development usually consists of informal domain-modeling sessions with the resulting domain knowledge residing in the heads of key individuals. Trying to translate these vague and intangible concepts (boxes and lines, for instance) into concrete development artifacts (source code) can be problematic not only because of the inherent complexity of the domain and its nuances, but also because implementation details can be left up to the interpretation of the person doing the implementation.

Creating a domain-specific language (DSL) reduces the chance for incorrect interpretation, while providing a reusable and concrete implementation of domain models and domain concepts. However, until recently, creating a DSL has been difficult or impossible for a number of reasons. That’s beginning to change as IDE manufacturers have begun creating language workbenches to aid developers in creating their own custom DSL’s for easy integration into their IDE of choice."

If you’re in Chicago on October 11st, stop on by. But please, if you heckle me and want to throw things, I prefer the large, chewy sweetarts.

Related Posts:

  1. Domain Specific Languages = The Long Tail of Programming Languages ( Part 1 )
  2. Domain Specific Languages = The Long Tail of Programming Languages ( Part 2 )

There's always room for Jell-O

Once of my favorite little diversions is looking at my blog stats and seeing how people are coming to my blog.  Most blogs keep track of referring addresses, and in the case of search engines, the actual query that led them to my blog.

Well, today I found this referring query:

what does jello and the Creation have in common

Apparently, if you perform this query using Bell South’s search engine, a post by me comes up as the 4th result.  Alas, it appears that THEY may be on to me with regards to my thoughts on Jell-O, and it’s use in placating the Flying Spaghetti Monster.

.NET is a vampire?

On Sunday, I received this post to a forum for one of my side projects ( A .NET framework ):

"Please do not develope components for .NET  It has become required for a few
companies apps like Sony and ATI. It installs over 15,000 registry entries!
It is a complete hostile takeover of a system. It does not benefit the user.
It is very similar to a Vampire. A vampire must be invited in to give it power.
The .NET component must be downloaded of your own free will to give it power.
They cannot sell it to you as that would be illegal due to what it does once
it is installed. Please study this issue carefully through forensic examination
to reveal exactly what .NET is actually doing for both you and for the master
controllers. This is a dangerous trend in computing. Please do not support it
and especially do not support companies that require it."

I always knew .NET was sucking the life out of me and now I know why!

Parallels & Function keys

As a Mac user, I used to love the set of function keys at the top of my keyboard that were shortcuts to control various functionality like volume, brightness, etc…

However, as I started to do a lot of work with Parallels Desktop, i found myself wanting to use the function keys in Windows.  Now, this is supported, however, you have to hit the Fn key plus whatever function key you actually want to use.  Needless to say, this can really throw off your rhythm when doing things like coding.

I was poking around my System Preferences the other day, and found a little known option under the "Keyboard and Mouse" category.  Under the "Keyboard" group, the option "Use the F1-F12 keys to control software features", when selected, inverts the function keys so that they act as normal function keys.
Is it me, or does that verbage seem reversed?  Eh…

You can still use the keys to control the volume and brightness, you just have to press the Fn key plus the desired function key.  That’s something I can live with.

Now, when working in Parallels, your function keys act like normal function keys.

So, if I ever go back to my saucy mistress, it will be a lot easier to take advantage of the functionality.

What is the Semantic Web and why should I care? – Part 2: Metadata

This is the second article in a small series that will look at trying to explain the Semantic Web, while attempting to leave people better informed as to whether the Semantic Web, or any part of it, is the right solution for their problems. Since some of the core ideas behind the semantic web are rather abstract, i’ll be tackling it in small chunks, with shorter posts meant for easier digestion.

In part 1 of this series, I described about the two aspects of the Semantic Web, and covered the first of those, common shared meaning. In this article, I’ll expand on the second aspect, machine processable metadata.


Data, there’s tons of it. The only way to make heads or tails of it is to store data about the data. That, in a nutshell, is metadata. Data about other data. The statement “His first name is John” says that John is first name of someone. This is a pure english version of meta data. The piece of data here is John and it is assigned some metadata that gives us more information about what the data means. In this case, someone’s first name is John, as opposed to their last name.

Since the Semantic Web definition we talked about in Part 1 specified machine processable metadata, we need to be able to transcribe metadata so that computers can parse it. As an example of transcribing metadata, let’s look at this example XML:


In this case, John is the data we are talking about and <firstName> is the metadata we use to describe the piece of data.

However the problem is that just like the data itself, the actual metadata that we store can have an infinite number of values. While having an infinite numbers of available choices for the data is expected, we should be able to narrow down what metadata we know about and expect. We need a way to be able to specify a range of acceptable values so that machines can parse the metadata. For data in XML format, this is where XML Schema comes into play. XML Schema allows us to specify a schema:

<xsd:element name=”firstName”/>

To define what metadata can be found when parsing our data. However, just as XML itself can only specify the syntax of the data we expect, XML Schema can only specify the syntax of the metadata we expect. They have no ability to represent any semantics about our data. The element ‘firstName’ could be ‘aaaaaa’, and a computer wouldn’t know the difference. We need to use some other means to represent semantics when storing data.

Enter RDF

RDF stands for resource description framework. It is comprised of three basic concepts:

  • resources
  • properties
  • statements

Resources are the things that you are describing. People, places, books and articles are an example of resources. Properties are attributes about those resources. Hair color, address, author, and magazine name are examples of properties that I would use to describe the resources above. Statements simply assign values to properties that describe resources. Putting the three together, a statement would look like this:

Griffin Caprio lives in Chicago

In the above statement, “Griffin Caprio” is the resource, “lives in” is the property, and “Chicago” is the value that we’re assigning to the property “lives in”. Now, RDF can take many serialized forms. Since I have been using XML up to this point, we’ll concentrate on RDF’s XML representation. Thus, the above statement would look something like this:

<?xml version=”1.0″ encoding=”UTF-8″>




<rdf:Description rdf:about=”http://blog.1530technologies.com/author”>

<rdf:type rdf:resource=”&myNS;bio”/>




The <rdf:Description> element says that this piece of RDF describing the resource specified in the about attribute. The <rdf:type> element creates a connection between this RDF statement and a type in my schema. The <myNS:livesIn> element is an element from my own schema that I am assigning a value to.

That’s it. That’s RDF.

So what?

That’s it? Yup, basically that’s all RDF is. There are some more elements and attributes, but these are the basics. Honestly, when I first heard of RDF, it made no sense where it would be useful. I even read an entire book on RDF, and still couldn’t make heads or tails of why it was useful. It seemed to some elements ( Description, type ) and a attribute ( about ), but other than that, you still had to use your own schema ( the myNS:livesIn element above ). To bend your noodle a little more, there’s even a simplified syntax for representing RDF in XML that is allowed. Thus, the above RDF/XML snip can be represented as such:

<?xml version=”1.0″ encoding=”UTF-8″>




<myNS:bio rdf:about=”http://blog.1530technologies.com/author”



Wait a minute, so in the above, the only thing I’m adding is surrounding <rdf:RDF> tags and about attributes? Wow, I feel the Semantic Web engrossing me already

To me, I couldn’t figure out what the difference was between this and getting everyone to use the same schema. I figured I just wasn’t getting it. But, if this was such a important technology, and the cornerstone of something like the Semantic Web, surely, someone should have been able to come up with a use for RDF since it’s inception. I mean, the authors of the rdf syntax specification are very bright guys and Tim Berners Lee ( Author of the WWW, perhaps you’ve heard of it? ) firmly believes in RDF as a key component of the Semantic Web. So what am I missing here?

Enter RDF Schema

It turns out that just like there is XML Schema for specifying the structure and syntax for XML files, so to does RDF Schema exist for specifying the syntax and structure of RDF documents. However, and this is a key difference, XML is still useful without XML Schema, while, IMHO, RDF is useless without RDFS. This could just be my opinion, but since no one seems to:

  1. Know anything about RDF, despite it being around, in one form or another, for almost 8 years.
  2. Even know that RDFS existed, despite RDF actually being described by it.

I feel pretty confident in putting forth my theory.

RDF Schema gives you the ability to define semantics for any domain that you want. By defining classes of objects and their properties, users can define relationships between resources. Let’s use a modified version of the example I talked about in Part 1. We have data that looks like this:

<executive>Bill Johnson</executive>

<intern>James Smith</intern>

Our problem is, how do we query this data for all employees? Syntax-based queries, such as XPath, would not be able to support this. However, using RDFS, we can define a RDF Schema document that does 3 things:

  1. Defines an ‘Employee’
  2. Defines an ‘Executive’, that descends from ‘Employee’
  3. Defines an ‘Intern’ that descends from ‘Employee’

Now, we can use an semantic-based query, such as a RDF query, to return all employees.

Now, i’ll talk a little about one aspect of RDF/RDFS that may have you scratching your head and I’ll define the RDFS for the example above. So, if you don’t care about the guts of RDFS, feel free to skip to the next section.

Ok, for those of you still with me, it may amuse you to know that when you define RDF types using RDFS, you use the <rdfs:Class> type, such as:

<rdfs:Class rdf:ID=”employee”/>

<rdfs:Class rdf:ID=”executive”>

<rdfs:subClassOf rdf:resource=”#employee”/>


<rdfs:Class rdf:ID=”intern”>

<rdfs:subClassOf rdf:resource=”#employee”/>


Here is the RDF Schema for our little example above. What’s interesting is that the RDF Schema for RDF Schema itself looks like this:

<rdfs:Class rdf:ID=”Resource”/>

<rdfs:Class rdf:ID=”Class”>

<rdfs:subClassOf rdf:resource=”#Resource”/>


For those clever readers, you can see that a Class is a type of Resource, which is a type of Class. Oh, and Class is defined using itself. Is it any wonder that these concepts are a little hard to grasp for most people?

Now, forget about RDFS ( kinda.. )

Hopefully the value of RDF/RDFS is beginning to come through. By being able to define higher level semantics using RDFS, your RDF documents become a little smarter. This is where the second part of the Semantic Web definition comes into play. With the addition of RDFS, your metadata AND semantics become machine processable. This is because RDFS is a primitive ontology language. Ontologies are formalized semantics. We defined a simply ontology above when we mapped the hierarchy of Employee, Executive, and Intern.

Unfortunately, the key word in the previous description of RDFS is PRIMITIVE. RDFS only allows for very simple relationships and semantics, mostly centered around hierarchies. “Executive” descends from “Employee”, for example. In order to specify more complex semantics, a more robust language is required.

This is where the Web Ontology Language comes into play. Incidentally, the TLA for the Web Ontology Language is OWL….HUH? Shouldn’t it be WOL? Eh, the craziness continues….

Coming up for Part 3….Ontologies: Semantic Data Nirvana?

Related Posts:

* What is the Semantic Web and why should I case? – Part 1: Semantics

Adding a Google Sitemap to your Typepad Blog

Recently, I found Google webmaster tools which give you some visibility into your site. You can find problems in your site like broken links and also see some interesting performance stats too.

However, the biggest reason to use the tools is it’s ability to help Google crawl your site better. You can upload a sitemap that tells google about your site so that your site rankings can improve.

If you have a Typepad blog, it’s very easy to publish a site map. However, you need to have a Pro account, since this solution takes advantage of the advanced template feature. I originally found a example template here. However, it didn’t quite meet my needs, so I created my own.

You can find it here.

To install it, just go to your Typepad blog control panel, and click ‘Edit Current Design’. Click the ‘Create new index template’ link, and give the template a name like “Google Sitemap”. In the ‘Output File’ textbox, enter in the file name that you’d like to use for your generated sitemap. For the template body, paste in the contents of the sitemap file found above. Save your new template, and that’s it.

Now, give Google the location of the newly created sitemap, and Google will crawl your site more efficiently.


15 things I learned from "The Big Moo"

*** Updated ***: I’m closing out comments on this post because a high google page rank plus comments equals tons of spam.

I recently finished reading “The Big Moo“, edited by Seth Godin. For those of you who aren’t familiar, it’s a collection of short blurbs for an assortment of authors, all centered around the theme of “how to become remarkable”. It’s a quasi-followup to Seth’s other book, “The Purple Cow“, which was about coming up with something that consumers think is worth remarking about in the first place.

I wonder if this is similar to how Jim Collins came out with “Good To Great” as a follow up to “Built To Last“. “Built To Last” is one of the best business books you could ever read, because it describes the the habits that extremely successfully companies have in common, regardless of what their actual business is. It does this by comparing 18 “visionary”

companies against a control group of 18 “successful, but second rank” companies. For example, Disney Pictures vs. Columbia Pictures, Ford vs. GM, etc.. While the results are fascinating, the one knock on the book is that it’s useless unless you’re starting a company, and since the vast majority of companies out there are already in business, there was little value. That’s why Jim Collins wrote “Good To Great“, to provide information for those companies that yearned to transition to the “visionary” status.

Perhaps people found “The Purple Cow” to be too “pie-in-the-sky” ?

Anyway onto my moo’s:

1. Real security comes from growth ( Page xiv ) – To me this is the best statement in the book and it’s right there in the preface.

2. Wanting growth and attaining growth are two different things ( Preface xv ) – Companies usually end up paralyzed by trying to focus on how they’ll grow instead of actually growing.

3. Those who fit in now won’t stand out later ( Page 5 ) – It’s difficult to change once you get into a rhythm of mediocrity.

4. If you name something, you get power over it ( Page 18 ) – Ever try to change a bad nickname ? When a name catches on, it becomes very powerful.

5. Don’t concentrate on making a standard. Once you create the standard, you’ve created a commodity and your customers will seek something like it, but cheaper ( Page 23 ) – *cough* Netscape *cough*

6. Being efficient is not as good as being robust ( Page 52 ) – There’s such a thing as “good enough”. Being flexible is better than trying to squeeze out a few extra performance cycles.

7. You can’t predict the future ( Page 55 ) – I already talked about this.

8. Everything is version .9, waiting for just one more upgrade before it’s done ( Page 86 ) – Releasing something stable, but not complete is better than waiting it’s “perfect”. It will never be perfect.

9. Betting on change is always the safest bet ( Page 91 ) – You can’t constrain change. People have scars from trying to.

10. Creativity is made up of iteration and juxtaposition ( Page 95 ) – Mash things together enough times, and something interesting will happen.

11. Compromise kills. Doing something half-ass is worse than doing nothing ( Page 97 ) – If you don’t have enough information to implement something, ignore it and move on. It’s better than trying to guess. Remember #7.

12. Novelty for the sake of novelty is risky and a recipe for irrelevance ( Page 100 ) – Solve a problem. I’ve written about this again and again

13. The energy isn’t in the idea, it’s in the execution ( Page 101 ) – Everyone wants to sit around and think up cool stuff. Sooner or later, you’re going to have to actually build something.

14. A product is what the customer thinks it is ( Page 131 ) – How many times have you gotten pissed at a user of your software for “using it wrong” ?

15. Don’t let the seeds stop you from enjoying the watermelon ( Page 134 ) – The world is grey. Every solution, product, feature is the result of several trade-offs.

Good book for anyone out there who wants to become an agent of change.

Trying out some social sites: LaLa and BookMooch

So today I decided to give some new Long Tail trading sites a try. Today, my first shipment of LaLa shipping materials arrived. if you’re not familiar with LaLa, it’s a CD trading service. You go through their site and add CD’s you’d like to receive to your wish-list. Then, you add CD’s that you wouldn’t mind parting with. If your CD’s appear on someone else’s wish-list, you tell LaLa you’d like to send the CD to the person. Using a special envelope they send you, you unlock the recipients address, and ship the disc off. They take care of the postage. The more CD’s you ship, the more you can receive. Each disc costs you $1.75, which isn’t a bad deal.

So a few days ago, i listed about 30 CD’s to ship, and added about 34 CD’s to my wish-list. All the CD’s I listed were in my shopping cart on iTunes, so they’re a mix of recent and old stuff. Tomorrow, i’ll ship out my first 5 CD’s, and hopefully, i’ll get some in return.

The other site I’m giving a shot is BookMooch. It’s almost the exact same setup as LaLa, except for books. You add books you have to send out to your inventory, and if they match a book on someone else’s wish-list, the ask you to ship the book to them. For every book you add to your inventory, you get 0.1 points, and for every book you ship you get 1 point, and every book you get costs 1 point. Leaving feedback also gives you 0.1 points.

Again, a few days ago, I listed 35 books I have, and a few dozen i’d like from my amazon wishlist. The main difference between BookMooch and LaLa is that BookMooch leaves all the shipping to you. I just got some emails from people who want my books, so I’ll run to the post office tomorrow. The nice part is that you don’t need to wait for the recipient to get the book you send before requesting a book be sent to you.

I’ll be interested to see if this model takes off and if I like it.