I'm spending some time doing some technical spikes to see what is possible and I found a need to load a particular file from a git repo given the path and tree hash.

I grabbed my trusty python, dulwich (native python-git library) and gave it a shot. After a few minutes writing complicated looking recursive code I jumped over to irc where the friendly author pointed me to a convenience function that does what I needed.

Here is the short answer:

from dulwich.repo import Repo
from dulwich.object_store import tree_lookup_path

r = Repo('/Documents/projects/gitdep/rails')
def get_file(tree, path):
    (mode,sha) = tree_lookup_path(r.get_object,tree,path)
    return r[sha].data

tree = '7e7331fce169bbe1d6be71a30c1e1f7ab2e6ceba'
path = 'activemodel/examples/validations.rb'

print get_file(tree,path)

This gives me a rails validation file from last year. Nothing special about this file, I just find the rails git repo an interesting playground for git experimentation.

I picked up a 4lb HP DM4 and dual booted to Ubuntu with not issues.  The trackpad didn't work right, but a script off someones blog made it work reasonably ok.  A quick hop into debug mode showed that the drivers returned negative x-y coordinates when you use 2 fingers.  I downloaded the open source drivers to take a look at the code and saw that a patch was already in head.

Developing was a joy and eclipse opened nearly instantly.

Microsoft silverlight DRM is not (yet?) ported to linux so I dual boot to windows 7 to get the customer experience and use CIM products.  A funny thing happened to me while getting the 'customer' experience.   I liked it!   Windows 7 is much more usable then either osx or Linux and IE9 looks like it will be a really powerful platform for future development.

Around this time I picked up a python update on OSX and spent about 4 hours trying to get mysql and python to talk to each other.  I booted into windows and thought about how to use this platform as a development machine.

Enter BitNami. Rather then deal with version conflicts I grabbed a virtual machine that is close to my target server and installed VMware Player.  Mapping a windows directory to the virtual machine lets me edit files in native windows while running my build chain on Linux.  The browser I use for development is finally the same browser used by the majority of my customers and my dev environment is much closer to my server environment as well.

For not I'm working through the rough edges of this setup and trying to find a decent windows SSH client but this setup seems to have legs.

The premise sounds positive.  Basically they took OSGI, Spring and threw it on Tomcat as a web server.  The idea of being able to deploy OSGI bundles with the bag of beans development style of Spring is really compelling.

What this negative post is about is how they still don't get the 'web'.  My biggest issue with Java web development is that not enough attention is paid to modern web basics.  The very first thing that I noticed on the SpringSource website was the 15 year old style url.

http://www.springsource.com/web/guest/home

what is with the /web/guest/home for the homepage?  That is really bad SEO mojo

The idea of bundles that you can drop in for added functionality is fantastic, but you hit an ugly query string laden url like:

http://www.springsource.com/repository/app/library/version/detail?name=org.apache.myfaces&version=1.2.2

as opposed to the far more buzzword complient library of plugins for something like django:

http://djangoplugables.com/projects/django-compress/

While the Java page shows you the really easy lines of Maven xml to paste into your pom, the python based django system talks about the usefulness of the actual bundle you are looking at.

And compare the old school search page of:

http://www.springsource.com/repository/app/search

to the happiness of a large input box with realtime results on:

http://djangoplugables.com/repositories/

At least this is better then the time I read the Jython website and was greeted by a 'blink' tag

http://code.google.com/p/django-rest-interface/

I was pleasantly surprised to realize that they Python developers simply used the normal form processing to handle rest and didn't invent a new paradigm.

On an early project we tried to implement RESTlet for a java based REST application.  Under load we saw some strange problems and the code was reverted to normal servlets without too much pain.

The beauty of REST is its simplicity, yet there is so much energy being expended to 'simplify' it.

The real magic is to standardize on sending XML or JSON rather then url encoded data of an http form POST.

Temperatures in the 80's, so I took the kiddies outside. I put my cellphone on the trunk of my sisters's car, put the kids on their bikes, put skates on my feet and rolled out to enjoy the day.

Things were going well with my littlest one making turns at each end of the block. My sister pulled up and shouted some encouragement as she drove past. I waved and noticed my black cell phone on the white trunk of her car!

I started to skate hard, but I couldn't leave my girl in the street. I shuffled the girls back into the house and summoned the boy to watch them and tore off after my sister. I searched all the likely routes she would have taken but could not find it.

I called her and found out where she went and was determined to look again.

At this point I was pretty upset about this and feeling down.

So I got on my motorcycle and started looking for it. I rode a block at a time and dismounted to look. After about 15 minutes I realized it was looking pretty grim. I also realized I was out on my bike on a beautiful day, and any day you ride simply isn't that bad.

I had a similar occurrence with python the other day. I had to scrape some data out of a nasty, IE only, webapp. It was pretty ugly but I got into writing the app as a pyunit test case and using assertions to ensure I got all the data. The difficult nature of the data coming in made me appreciate just how much you can do with test cases. The scraping task was about as pleasurable as looking for my cellphone across town.

But at least I got to do it in python and enjoy the ride!

Most of the Flash backend in our work is xml based so XML was on my mind anyway. Recently we needed to mock up a xml data data file for a project while the real APIs are being completed. We had the data in a csv file so we asked some developers to whip up a xml file.

As I started writing up the ticket I started thinking it would be easier to just do it myself.

Given the speed of python development I was right!.

#!/usr/bin/env python
"""
cvs2xml.py

Created by Aaron Held on 2008-04-11.
Make the xml from the csv using dom and other three letter acronyms
"""import sys,os
import unittes
import csv

from pprint import pprint
import xml.etree.ElementTree as ET

class Cvs2xml:
    def loadCSV(self):
        """Load the data and return a list of maps"""
reader = csv.DictReader(open(r"input.csv",'r'))
        rows = []
for row in reader:
            rows.append(row)
return rows

def mappings(self):
        """
        Map csv file to xml field names
        """
mapping = { 'id':"store_number"
        return mapping

def createXML(self,listofrows):
"""Turn lists into xml
"""
root = ET.Element("stores")
for row in listofrows:
store = ET.SubElement(root, "store")
for xml_field in row.keys():
csv_field = self.mappings().get(xml_field,xml_field)
ET.SubElement(store, xml_field).text = row.get(csv_field,"")
print(ET.tostring(root))
#tree = ET.ElementTree(root)
#tree.write("output.xml")

class Cvs2xmlTests(unittest.TestCase):
def setUp(self):
pass

def testRun(self):
'''Lazy way of main()'''
cvs2xml = Cvs2xml()
rows = cvs2xml.loadCSV()
cvs2xml.createXML(rows)

if __name__ == '__main__':
unittest.main()