Read Eval Bacon Loop

My take on Design Patterns

2009-07-20T11:03:00.000-07:00

In case you haven't filled your quota for reading sarcastic poorly written hyperbole about software construction I present my take on Design Patterns. Now with example python code.

Chapter 0: The singleton

Since the invention of the stack and data structure programmers have been hounded by people telling them not to use globals. The singleton exists to confuse people until they give up criticizing your code for the use of global variables. Use them constantly.

Chapter 1: Constructin stuff is hard.

Often times you want things but getting them is hard and fraught with complication. For example we might have a car object & constructor: Car(bankAccount). However we might want to abstract the nasty details of its construction since creating a car object should be easy:


class CarFactory:
  def __init__(self,bankAccount):
     self.bankAccount = bankAccount
 
  # We could make this __call__ or even use a closure but
  # this confuses java & c++ programmers who are easily
  # frightened with out many lines of boilerplate code.
  def createCar(self):
      return Car(self.bankAccount)

creditCardForCar = CarFactory(lifeSavings)

# now elsewhere the nasty "details" are abstracted away
myNewCarIcantAfford = creditCardForCar.createCar()

As you can see this is an ingenious pattern that is clearly better than using closures or currying of constructor arguments because now I have 2x as many objects.

Chapter II: Square pegs can go in round holes

Say you are using a poorly designed library or even better several poorly designed libraries that must interact together prehaps a result of the Ballmer peak. You will often have things like OMGBestLibraryEveryString and WTFBBQLibraryString. They are both strings that do that same thing but their authors seeing the clear deficiencies of using a standard string class have chosen to write a completely new one (because new is better). Its times like these you need one of two things: a bottle of wiskey or a design pattern. Put down that single malt its time to create some facades and proxy. There are two names because it would be boring to call something a wrapper pattern. Also people might think you were saying rapper pattern which would lead to profound confusion and eventual disappointment. in this case we do the following:


class FacadeWrapperProxyOfOMGBestLibraryEveryString:
   def __init__(self,bbqstring):
       self.bbqstring = bbqstring

   # no reimplement all 50 of bbqstring's methods 
   # and overloads minding painful edge cases and 
   # bugs! (you can get the wiskey out again)

Now everything is wonderful again.

3: Messages and misc stuff

Turns out even though OOP is modeled after passing messages to objects methods are not suitable for publish subscribe or message passing systems. This is very fortunate because now you can write extra objects to facilitate this lack of foresight.

Chapter iv: This chapter is missing because of a race condition in the chapter singleton manager factory.

Chapter 5: Take back that CS theory

Its really annoying when you are trying to engineer software and some "computer scientist" starts talking about algorithms and uses confusing words like state machine and language translation. Fear no more! They are now patterns! If someone suggests they are not just look perturbed and hand them a copy of design patterns.

Canceling Xna

2009-06-19T11:32:00.000-07:00

After a year of not using XNA creator's club and being generally morally opposed to the whole concept I decided to cancel it. Long story short this requires contacting xbox support (weeee). The only truly annoying part is how hard it is to find out this is what you must do and what the phone number is you must call.

It seems borderline unethical to not have a mechanism for canceling your account that is as easy as signing up.

jQuery bounding region plugin

2009-06-18T15:32:00.000-07:00

While working on some javascript network visualization software I am coding for work I came up with a jQuery plugin function that calculates the bounding box around the query using offset() and width() and height() returning an object that has left,top,bottom, and right members.

(function() {
   jQuery.fn['bounds'] = function () {
     var bounds = {  left: Number.POSITIVE_INFINITY, 
                      top: Number.POSITIVE_INFINITY,
                    right: Number.NEGATIVE_INFINITY, 
                   bottom: Number.NEGATIVE_INFINITY};

     this.each(function (i,el) {
                 var elQ = $(el);
                 var off = elQ.offset();
                 off.right = off.left + $(elQ).width();
                 off.bottom = off.top + $(elQ).height();

                 if (off.left < bounds.left)
                   bounds.left = off.left;

                 if (off.top < bounds.top)
                   bounds.top = off.top;

                 if (off.right > bounds.right)
                   bounds.right = off.right;

                 if (off.bottom > bounds.bottom)
                   bounds.bottom = off.bottom;

               });
     return bounds;
   }
 })();

Network Visualization in the Browser

2009-03-20T11:38:00.000-07:00

I am working on doing network visualization in javascript using html canvas via John Resig's excellent processing.js. Right now it uses a force directed layout system where each edge in the graph has a spring and all nodes repulsed from each other. I noticed the results seem to be work best in firefox but not safari which makes me wonder if some of the Math object functions differently between the two? Once I separate out the connected components and remove the artificial walls around the simulation it should provide better results since the repulsion system wont cause the graph to expand indefinitely.

This will be part of a large visualization system which I intend to open source if I can. The other part being a diagram tool more suitable for point to point circuits.

Here is a link to my current prototype visualizer.

Building internal webapps

2009-01-27T11:17:00.000-08:00

I couple months ago I picked up Enterprise Integration Patterns. It was a lot better then I thought it would be considering it contained the word enterprise in the title. The premise of the book is that using message queues/buses allows for easier integration of applications even spanning organizational boundaries.

This got me thinking about web services exposed through REST/http. One of the nice benefits of http is that it has clients in almost every language and environment. While exposing services and tools with a http interface can solve more than the immediate problem of feeding your ajax app it can also allow a larger set of people to leverage your service.

It seems like the smartest thing any organization that has lots of internal services could do would be to make a directory of such services maybe even use RDF. Of course the problem is the reliability of these services may vary depending on the needs of the original author and the maintainer. Requiring the author of every web service to make sure their service is up 24/7 might not be appropriate.

Rotations and lame network cards

2008-12-15T22:28:00.000-08:00

It occurred to me while debugging my 3d camera that rotations are far to rotatey. R^T = R^-1 = R(-a) which means if you have a bug it can be confusing and potentially work to some degree even though really your code is completely crazy. In this case I was uploading rotations into opengl that were row major when it is in fact column major. Another amusing thing is if your rotation is several rotations such as R = r(a)r(b)r(c) then R^-1 = r(c)^-1 * r(b)^-1 * r(a)^-1 which means your rotations are now going to be done in a different order in the opposite directions.

I would also like to thank my marvell yukon network card for failing at life. It was trying to offload checksum calcs in vista but doing a worse job than my CPU. So much so that it was causing team fortess 2 to be inoperable. Luckily these things can be adjusted.

Fan!

2008-10-23T01:16:00.000-07:00

Interesting new language named fan? Seemed nifty. However their stance of generics seems a bit odd. Generics suck so lets build a couple cases into the language... Hmmmmmm

Hmmmmmmmmmmm......

Discus!

Programming languages! Programming languages!

2008-10-21T23:56:00.001-07:00

ANTLRWorks is like crack. I am trying to build a bastard child of ml and ruby and maybe a little scheme mixed back in for good measure. One of my favorite features from haskell is the pattern matching which seems like a no brainer for adding to a scripting language.

I have also been picking up ruby lately and its surprising how good it is. Some people compare it to being similar to python. This is not the case--it has a lot more delicious features. Succulent indeed.

Then there is groovy which is subtly disappointing but sure as shit beats writing actual java but not by enough. At least java makes sense in its own crippled and ridiculous way.

Try passing a function as a value in groovy from inside it self. Sure it has whatever hack is needed for recursion but apparently it is only half-baked. Very disappointing. How am I supposed to use recursion in conjunction with higher order functions? I may post something somewhere so it can some how get fixed. Its kind of embarrassing to bring up so it seems more sensible just to make my own language (yup I am crazy).

Wont someone please think of the functions!

Anyways ANTLR is awesome and I am sleepy. I will probably post more of whatever language I cook up if it ever amounts to anything.

The annoying thing about everything programming...

2008-10-08T03:57:00.000-07:00

Java is like a mysterious creature. The language itself has no grandeur or mystery with its decrepit non-unsigned-integer body but as a technology it is at the very least a nice way to get a garbage collector that doesn't suck too much out of things. It's also amusing seeing just how hard people are willing to work to get the language into a state that is actually usable.

This stems from a long line of tradition most likely (I am entirely making this up) of taking boring language X and tarting it up. Some languages have stream lined this process by adding macros, templates, dsls and all manners of delicious treats to tantalize programmers with their deviously delicious syntactical and semantic confectionery but at the core of most of the language is a dull and powerless language.

What is interesting is the lengths we go to pave over the obvious problems. Your agile OOP programming language not as agile as you wished? Integration getting you down? Have no fear inversion of control--IOC is here to randomly give you a chain saw and a stirring spoon so you can recombine your classes like some kind of Frankenstein soup.

Its actually not an entirely terrible idea. This is because while programming in a language whose name shall be protected to well protect things I ended up pretty much coding one. A bad one mind you but now that I started learning spring I realized it. But like most random-chainsaw enhanced Frankenstein soups they must be used with caution.

I also more or less discovered a really bad version of lisp this way (thanks C++). The problem with programming languages is perspective. A person wearing their java goggles only sees insanity in the C and dynamically typed/interpreter camps. Same goes for languages. Functional programmers can only think of how stupid C++ is etc...

At the heart of the problem is that every programmer is secretly and silently searching for "the solution". Its hardwired in our brains like some kind of brain damaged salmon. We can not escape getting lost up the metaphorical drain pipe of language zealotry. The fact that something so important could mired in duplicity is like some inefficiency: to be compressed, optimized and ultimately erased.

This doesn't mean java is a steaming pile of poorly design dog poo as a programming language its more profound than that. We maybe mired one collective dog poo of non-orthogonality. However it does not help things when people are seemingly willfully ignorant.

Some of it is good old fashion good nature idiocy that we maintain at some level pretty much as soon as we are capable of having an opinion. Part of the problem is that computer science gets distilled as technology and through this process of decanting becomes a form of canon. Relations go in a relational database. Lisp is for crazy guys who write AI. C is a good idea--along with the Von Neumann architecture. The practical reasons for these decisions forever lost to most people as forests whose trees will never emerge again.

We use these familiar tools as crutches to form our ideas on how to solve problems never stopping to wonder in greater detail or perhaps fearful of dizzying height technology has built upon itself.

Diffing and journaling xml documents

2008-10-02T01:02:00.000-07:00

I am somewhat sleepy but I think its time I ill advisedly hurled some thoughts into my blog.

I inherited a project recently that I got around to finally working on involving synchronizing network device data in a db using diffing/journaling using xml documents.

The problem with finding the difference between two xml documents or anything for that matter is deciding on a set of operations that will be used to transform one to the other. Then real problem though in the case of my problem is given two xml documents what is the optimal set edits that transform one to the other.

Traditionally utilities like diff find the LCS to minimize the number of edits. In this case I wanted the edits to be as granular and as simple as possible. With a one to one correspondence it makes updating things like a database with the change set an easy task.

The method for actually determining what is different in an xml document is the interesting part however. In the case of structured data like xml you often have collections of entities such as network interfaces which all have some defining characteristic such as a name or id code. This can be used as a key to compare the nodes in the xml tree so that even if they are out of order they can still be properly compared.

The reason for wanting to be able to handle unordered collections of things (sets some might call them) stems from the initial problem it self mainly lack of information. If for some reason the interface is discovered in a different order you really don't want adds and deletes generated simply because it moved.

The way this all ends up being computes is using xpath expressions. One expression expression to determine a node set in each document that is potentially comparable and another to which is applied to each individual node in each document which returns the key used for determining if the nodes have the same name/identity.

Sometimes problems are only as simple as you allow them to be. In this case a fully generic diff or comparison on a pair of xml documents hardly makes sense. Without some information about the meaning of the documents the data that would have a high potential for being unwieldy and useless.

Of course I have thought about abandoning the diff/journaling model all together but unfortunately having a list of exact changes that have taken place is too useful.

Embedding IronPython

2008-04-20T22:13:00.000-07:00

I am trying my luck with embedded IronPython 2 using the DLR so I thought I would share some of the steps to make that happen.

Prereqs:

Microsoft.Scripting.dll
IronPython.dll
IronPython.Modules.dll

These all come from the IronPython2 beta 1 release--and yes you need all of them. Failing to add IronPython.Modules.dll as a reference results in strange errors when trying to get the scripting engine which can be confusing.

The interface to IronPython and presumably other DLR languages is through the Microsoft.Scripting.Hosting.ScriptEngine class. There seems to be about a billion ways to get the engine here is what worked for me:

ScriptEngine engine; engine = PythonEngine.CurrentEngine;

This gets/creates the ScriptEngine for IronPython. Next we create a Microsoft.Scripting.Hosting.ScriptScope which allows for variables to be bound on the embedder's end before the script is run. It also can be inspected after the script is run.

ScriptScope scope = engine.CreateScope();

Now all that is left is to load the script woooo. Doing this creates a Microsoft.Scripting.Hosting.ScriptSource object which can have fun things done to it.

ScriptSource source = engine.CreateScriptSourceFromFile("myScript.py"); source.Execute(scope);

This loads a script and then executes it using the scope that was created. The contents of the scope can be examined afterwards like I said which can be useful if you want to create factories that return an extended C#/CLR class that can then be used like normal.

TacticsGame game = scope.GetVariable("game");

This gets the global "game" form the script. In order for this to work right you need to add the assembly references to your script. This can be done in two ways. First you can do it the normal way from inside the script:

import clr clr.AddReference("MyAssembly.dll")

This works but its kind of annoying if MyAssembly.dll is actually the same assembly that the script is being hosted in or some other assembly that is known. Another way is to call engine.Runtime.LoadAssembly and feed it assemblies it should know about. See System.Reflection.Assembly for some ways of getting these assemblies.

Hopefully this works a bit better than boo did!

Embedding example: An informative but trying on the eyes tutorial.
IronPython Website: In all of its official and incompletely documented glory.

XNA ContentManager.RootDirectory Considered Annoying as Hell ( XCCAH)

2008-04-20T13:46:00.000-07:00

Beware of older XNA code using code created by the new project templates! The newer code sets the root directory of Content to "Content/" which breaks all my old code and was very confusing. Which leaves me wondering if they are going to include that as the default why not change it in the class! Blargg. Now any "game libraries" which have content that gets loaded have to worry about what the RootDirectory setting is at unless they use their own ContentManager.

ContentManager.RootDirectory Property <-- boo

Time to put patches down.

2008-04-16T17:52:00.000-07:00

When you are coding what we might call language X and you ever think "yay it actually lets me do this non-stupid thing" such as map, filter or anything really a sane person might need when constructing software then you know you have a problem.

I am looking at you perl 5.

*glare*

Ruby,anything from ml,python,scheme,lisp... I can't count the number of better languages suited for most jobs perl gets used for still. I normally not a language zealot but jebus! If I see another perl hash with elements whose values are "1" because perl has not set data type I am going to vomit.

Perl is not regression in programming languages as much as it is a scripting language that is on life support. Its an old man clinging to life after a long and fulfilling life. Its time to pull the plug and let gramps die in peace.

OK I lied it probably was but lets just let it die in dignity. Perl was one of my first scripting languages so well I hate it slightly less than I should but still...

You know its bad when you would rather be writing java than perl. Actually its not too bad with anonymous classes. Why the hell they don't add anonymous functions I don't know. I guess they don't want to ruin the master piece that is java.

mmm rant tastic. I need to record my insane ramblings so that whatever future society goes through my blog (cause you know they will) gets the record straight. I am one of those scary computer scientist Larry Wall warns you about in programming perl--and I hate sunshine puppies and probably a lot other things. Especially kittens. I also eat metal scraps and speak in binary. In fact I often eat kittens for desert while speaking in binary.

Wendorb

2008-04-01T22:04:00.000-07:00

Mmmm cafe!

Java Restlet api rocks

2008-01-30T16:17:00.000-08:00

I have been using the java Restlet api for network topology stuff and it is quite nice. Seldom do you come across cleanly designed APIs these days it seems. It avoids a lot of the common pit falls java apis seem to enjoy:

Factory diarrhea == teh sux: Everyone who has used java has probably experienced this. If you are writing api realize that most people don't give a crap about a configurable factory. Give people concrete instances of things that default to a particular implementation. Configurablity is good but I should not need to enter a deep philosophical debate with my compiler just to determine how it should parse XML.
Fixed verbosity: Most libraries have a fixed way something must be done. More than likely the level of verbosity required to do it inappropriate for what the user is doing. Design your classes so they can function with out extra functions calls and other pointless boiler plate code if you can. When the user needs more control they can specify it when needed. People can learn your library faster and programming with it will be much more pleasurable.
Documentation: People seem to have strange ideas about what appropriate levels of documentation is. Hint: you need more than just javadocs/doxygen output. Your software should be the sum of its parts. Documenting the individual pieces in isolation with out providing more detail makes learning how to use your code orders of magnitude more difficult.
Use standard abstractions: If the language provides a standard library with things like iterators and structures use them! If programs are essentially language recognition and translation (which they are) then using common concepts is essential. If you don't do this you are failing at communicating with the people reading your code and also doing a poor job communicating with the machine which you are instructing.

There is a billion more tips but these are the major ones.

Rolling your own CSS

2008-01-28T13:31:00.000-08:00

Having an easily data driven method for customizing style information can be invaluable for building nice user interfaces. For special purpose user interfaces like games it is even more important. Designers need to be able to easily skin and customize different UI elements with out having to alter source code.

UI Elements as Properties

To control the look of user interface elements a simple flat set of properties can be used such as "background-color" or "font". A style sheet is simply a class that you can get and set properties from:


class Style {
  public object GetValue(IStyleable target,
                         string propertyName);

  public void SetValue(StyleSelecter selecter,
                       string propertyName, object value);
}

Just like in CSS a common way to refer to elements is needed. I used StyleID, a set of Classes and a Type to replicate the familiar id,class,elementType trio. This is formulated in a simple interface:


interface IStyleable {
  string StyleID { get; }
  ICollection<string> { get; }
  string StyleType { get; }
}

A predicate for if a certain property definition applies is needed:


abstract class StyleSelector {
  public abstract bool Matches(IStyleable target);
}

Finding a Property

Every selector must at the very least support the ability to find a property by an O(n) search--this is what the Matches method is all about. Finding a property consists of a search over a list property definitions (StyleSelector,name,value). If a definition's name matches and StyleSelector.Matches is true then the search is terminated and value is returned as the value for that property.

In order for the cascading part to make any sense an ordering of property definitions needs to be defined. CSS solves this problem with the notion of specificity. Properties with more stringent criteria for being applied are allowed to float to the top and are used over the more generic definitions.

For my purposes I organize things simply by id > classes > type > *. So selectors that specify the id of its target are examined first. This conveniently allows for property searches to be culled to smaller sets that must be visited. Hashtables for each of these categories can be constructed to speed up search times so that for example (id,name) is indexed. This reduces linear searching only to custom and other miscellaneous selectors.

Combining Selectors

Aggregated selectors can be formulated based the AND logical operator. Since AND is commutative the selector can be rummaged through for any sub-selectors that are indexable. This can then be used as criteria for which index the aggregation should be inserted into. For example #myButton:hover can be inserted into the id indexing table since it contains an id selector.

I will probably post the code to this and the rest of my GUI toolkit when I am done / bored with it.

Game Rules 1

2008-01-10T11:54:00.000-08:00

I mentioned I would talk about a domain specific language for game rules so I will but first a rant on why the term DSL is silly and some discussion on what a game rule itself will be.

The term DSL is kind of stupid

Like any good acronym one day you wake up and it is as if while you were sleeping everyone got together and decided to surprise you the next day. Suddenly people realized they could make their own languages to solve specific problems and that this was now the neatest thing since sliced bread and other suitably neat cliches.

It is not that I am opposed to them. I just find it appallingly annoying how computer science and the software industry is often reduced to fads. It is as if all the people who slept through their compilers courses (really when else are you going to get a nap?) suddenly realized that this information was actually useful. DSLs don't solve all of your problems--but being smart and knowing the theory behind them will transform them into useful tools. I suggest picking up the dragon book and books on automata and language theory.

What is a game rule?

When playing games generally there is a set of rules to play by. These usually follow as consequences for some action the player does. These rules can also be the consequences of actions by other rules. Such as a player moves his piece on a board game and receives 5 points. He already has 10 and it only takes 15 to win lets say. The rule for winning was based off an action from another rule (gaining 5 points).

A game rule is action and then a consequence or more formally a predicate and some function that changes the course of game play somehow. R = (P(s),F(s)) So to apply a rule P(s) must be satisfied. Then s := F(s). Of course fashioning this into an actual usable system will require more work which I will save for next time.

Game rule DSL maybe?

2008-01-03T23:43:00.001-08:00

I am cooking up an idea for a game rule DSL and will probably post more when I actually start working on it. I am also kind of sleepy right now but think of something db triggers except not awful and crazy.

Reading Wizards First Rule

2008-01-03T23:38:00.000-08:00

Started reading the Wizards First Rule by Terry Goodkind after a friend recommended it. Seems pretty entertaining so far! Time to go read more.

Leopard Keyboard Freeze Workaround

2007-12-10T17:52:00.000-08:00

Sometimes my keyboard freezes in in leopard apparently this is a known issue. You can fix it if you plug-in a usb keyboard! At least it worked with some dell keyboard that was floating around my desk. That would be a fun bug to track down. It triggers rarely and seems to be related to spaces usage. I thought about submitting the bug to apple but I couldn't find their bug tracker! I guess big companies don't need or care about user submitted bugs.

Design Pattern Soup

2007-11-29T14:24:00.000-08:00

While designing the class that manages my game objects the other night on a project I came across an interesting pattern. Using the visitor pattern with a mediator to add objects.

interface IRenderable {
  public void DrawMe();
}

class Renderer {
  public void Add(IRenderable renderable);
  public void Remove(IRenderable renderable);
}

This is normal looking code for most applications. The power of being able to add random things that can be drawn is very useful. There are several problems with this first it can be important what order things are rendered when drawing 2d and 3d graphics. Also for the purposes of batching it may be very important to group like objects together.

These two problems can make things somewhat messy. Its possible to overcome them naturally. For instance we could include an integer that describes the order which renderables are to be drawn and sort them that way. For batching each renderable could queue it self up for rendering and then after a certain number of objects are in the queue or if it needs to be flushed for example if we are done rendering. Of course the batcher would have to somehow register it self with the renderer also since presumably only the renderer knows when its done drawing and any retained style buffers need to be flushed.

There is a simpler way which at first may seem silly and that is to have the objects register themselves at the request of the renderer--basically the visitor pattern.


interface IRenderable {
  public void DrawMe();

  public void Add(Renderer renderer);
  public void Remove(Renderer renderer);
}

class Renderer {
  public void AddSpecialDohicky(Dohicky dohicky);
  public void RemoveSpecialDohicky(Dohicky dohicky);

  public void Add(IRenderable renderable) {
      renderable.Add(this);
  }

  public void Remove(IRenderable renderable) {
      renderable.Remove(this);
  }
}

This allows for all sorts of interesting behavior. Also IRenderable could still support a basic one size fits all DrawMe() call if needed. Another side effect of this is that the Dohickys don't have to actually to be implementers of IRenderable which leaves things wide open for using composition instead of inheritance.

Naturally the draw back is that the Renderer is coupled with Dohickies but it makes it much easier to add optimizations to your renderer since it for example can cross coordinate with other objects being rendered so you do not have a bunch of objects operating in a vacuum simply for the sake of proper OO design. Like everything its all a matter of trade offs.

Hellgate London

2007-11-20T23:15:00.000-08:00

Hellgate London is a fun game but it lacks polish. I have had it crash twice on my 2 GB machine with an out of memory error and on two other separate occasions objects appeared to stop updating.

It also is missing some things I kind of hoped would be no brainer additions from Titan Quest. Do I really need these displacement do hickers or scrolls of identify 2.0? Also the setting is fun at first but once you have been in one london sewer system you kind of have seen them all. Hopefully the game will transition to being just in hell or something more interesting.

On a positive note I enjoy the number of rare monsters that seem to show up in the game. Basically that and all the classic diablo features make the game fun but the crafting/upgrade system seems to be adding an additional element of game play that is amusing. Still you would think certain things would basically become more or less standard in hack in slashes such as displaying DPS not just damage!

With some patches the game has even more potential. Despite my nitpicking and bitchery I still seem to be playing a great deal of it. If in a couple of months I am still playing the game then I suppose it really is a success (go partial reenforcement scheduling!).

I have defeted crysis!

2007-11-20T03:59:00.000-08:00

Very pretty game and long enough to keep me entertained! I kind of wish I could have blown more stuff up at the end but hey...

Now I am sleepy but first I must drink orange juice. Apparently I am participating in some sort of auxiliary thanks giving this friday also. Two turkeys... mmmm......

A relational model for REST

2007-11-19T18:09:00.000-08:00

For awhile I have had the desire to create some sort of fantastic contraption that combines relational databases and REST services that allows for people for example to mash up distributed data in a nice formal and hopefully automated way.

I do not know much about database theory but the main difference is that with a REST service it is usually impossible to enumerate a given set of relations. This is something a query planner/relational calculus could easily work around I would imagine. Naturally some types of queries would be impossible!

The other half of the solution would be a common registry of adapters and relations since such software would need to have definitions as to what nouns are compatible and how to convert between similar data but with different interfaces. This would make work writing software that uses distributed services much simpler. Imagine being able to do use SQL joins to mash data up!

Maybe I will try hacking such a system up when I am not playing one of the bazzilions games that just came out (Mario Galaxy is awesome!). Hopefully it wont be to hard to create a proof of concept.

Trying blogger

2007-11-19T10:39:00.001-08:00

I have realized I am far to lazy to run and host my own blog. This also has to do with the fact that I would rather spend my time doing other things. This is why I am giving blogger a whirl! Hopefully its not too terrible. One of my concerns is there was no model for just being a presistant store for an rss feed/rest service. But it has a system for ftping your blog to a site. How old fashioned!