Just in case you know anybody in Prague:
"Teddy Bears' Picnic" plays this Sunday, Monday and Tuesday at KINO OKO
Frantiska Krizka 15 170 00 Prague 7 Czech Republic
Judith Owen plays, with Harry Shearer on bass, Monday night at Zelezna Jazz Club
Zelezna 16 Praha 1 Czech Rep
Speaking of speaking at conferences, I will be doing that again at Chris Sell's Applied XML Conference in a couple of weeks. This time I'm using Python, which I consider a kissing cousin to the Lisp family along with Smalltalk, Ruby, and some others. Look at the code a couple messages below. You could wrap some parentheses around those statements and never blink.
Gordon Weakliem swears I turned him on to Lisp...
What led you to try Lisp?
I heard Patrick Logan speak at a conference about building web services with Scheme, which sounded interesting, so I read "The Little Schemer". Later, Paul Graham's writings, esp. "Beating the Averages", but also because I was feeling the limitations of the Java / C# family of languages.
Wow, Gordon. If only it were that easy with everyone else!
I recently started using JXPath, an XPath implementation for multiple underlying data models in Java. It works out of the box for DOM, JDOM, java.util.Map, servlet contexts, and Java Beans. Probably others.
I wanted to use XPath to query Jython objects. The really cool thing is the amount of code it takes to do so. It's so short I include it right here...
from java.lang import String
from org.apache.commons.jxpath import JXPathIntrospector
from org.apache.commons.jxpath import DynamicPropertyHandler
import jarray
class JythonPropertyHandler (DynamicPropertyHandler):
def getPropertyNames (self, py_object):
keys = py_object.__dict__.keys()
return jarray.array(keys, String)
def getProperty(self, py_object, property):
if py_object.__dict__.has_key(property):
return py_object.__dict__[property]
else:
return None
def setProperty(self, py_object, property, value):
py_object.__dict__[property] = value
def registerJythonPropertyHandler():
JXPathIntrospector.registerDynamicClass(PyInstance, JythonPropertyHandler)
And so...
>>> context = JXPathContext.newContext(some_object)
>>> context.getValue("frob[abc > 1]")
<__main__.Foo instance at 3278971>
Enterprise IT environments are a mess primarily because they've grown piecemeal by function and technology. Every business unit and indeed every project is "empowered" to make their own decisions. And so they rightly make the best decision for their purposes. Every vendor has some hook in their technology to bring you back to the trough.
Even if some Enterprise Resource Planner (ERP) met all your needs, how long before you could actually get to "All Your Base Are Belong To Us" nirvana? And so we have "Enterprise Application Integration" (EAI) and (new to me...) "Enterprise Information Integration" (EII). One approach to EII in the past has been to build a massive Enterprise Data Warehouse (EDW).
Another approach, Phil Windley writes in his blog item on virtual databases, "The biggest hurdle... is creating the... data model." and includes some useful references.
Another pragmatic source of inspiration is Ralph Kimball. First some history...
A significant contributor to the Xerox Star in the 1970s (which influenced the Mac, which influenced...), Kimball and peers at Metaphor in the 1980s pioneered data integration, iconic capsule programming, and end-user data analysis. Metaphor was sold to IBM and languished under the shadow of OS/2 politics.
In the 1990s Kimball went on to pioneer data warehousing design principles and the Red Brick OLAP database (also sold to IBM via Informix). He is now an independent consultant and popular author on data integration topics for OLAP.
His keys to an effective virtual database (or data bus architecture in his words) is conformed dimensions, smallest grain facts, etc. Most of these principles apply to the largest data warehouses or the smallest databases, and would benefit any Enterprise Information Integration effort.
Steve Gillmor on Microsoft and RSS.
Interesting ideas. But what is interesting about RSS? What is interesting about any protocol?
Maybe it's just that developers are using RSS and Microsoft likes developers. The protocol itself is nothing special, but that in itself is its advantage... witness the number of applications that implement it. It was designed by developers.
So simple protocols are good. Has RSS been through the scalability ringer yet? Does it matter? Another protocol will come along soon if necessary. The interesting questions are what to do with the protocol. That's what Steve Gillmor is getting at, perhaps.
