In middle school (at JDMS), I was becoming decently proficient at everything BASIC.  (Apple II, TRS-80 and DOS 3.3)  One of my math teachers mentioned to me that you could approximate PI by filling one quarter of a circle with an ever increasing number of rectangles of smaller and smaller widths.  And so I wrote a program to do just that.  Spent weeks running and rerunning it with different numbers of slices (and different methods of calculating the heights) and comparing the outputs to official known good values.  (and charting my accuracy)

I don’t remember exactly how accurate I finally got before they told me to stop running multi-day processes on the lab computers…  But suffice it to say: I was VERY nerdy.  =P

Where’s My Car? helps you find your car in a crowded parking lot. When you leave your car, simply open the application. (It will automatically get your current GPS location) Leave the application open, and when you’re done doing whatever it is you have to do, click “Take Me To It!” An arrow will show up (as well as a distance measurement). Simply walk in the direction of the arrow, and you’ll be quickly guided back to your car! BTW, I originally wrote this app as a present for my wife. I’ve decided to place it on the App Store as a FREE app because I don’t see why the other apps that do the same thing charge $5 for such a simple feature. Let me know if you like it!

UPDATE: It has been approved/published!  To download, open the App Catalog.  Search for “car”.  Click the coins icon in the lower-right to show only FREE apps, and “Where’s My Car?” should be the first in the list!  :)

UPDATE 2: Click here to download:  Where’s My Car?

Screenshots after the break…

One of the interesting aspects of the academic side of computer science is the creation if new terms for old ideas. Take a well known concept, add a twist of lime, invent a new term, throw in a little obfuscation, and presto – an instant publishable paper (as long as you’re not submitting to a top-tier journal). It’s publishable because it’s very hard to classify between these junk papers and complicated but genuinely new concepts. (so hard in fact many journals don’t even try – even nonsensical papers can occasionally sneak through) And since people are judged on how many papers they produce, this problem has become an epidemic. The signal to noise ratio is currently mind-bogglingly low.

Dependency Injection I’m now certain is the corporate equivalent of this academic phenomenon. While people many not have as much incentive without the threat of not getting tenure due to too few papers published, the fame of being the guy who invented The Next Big Thing(tm) is non-trivial. And even if you don’t invent it yourself, being an early champaign of The Next Big Thing(tm) distinguishes yourself from your peers, helps you land new contracts, etc. In a myriad of career enhancing ways it’s still a viable incentive.

Not to say it’s a con-job mind you. Buzz-words are everywhere in this business. It’s exciting to be on the cutting edge, and it’s hard to separate out the true leading fronts from the fake ones. It’s real easy to get swept up in the excitement. (I’ve been guilty of it myself on more than one occasion) But that doesn’t change the basic question.

So… Dependency Injection: A new idea or Coke with Lime?

Let’s start with Martin’s own sample code.

class MovieLister...
    private MovieFinder finder;
    public MovieLister() {
        finder = new ColonDelimitedMovieFinder("movies1.txt");
    }
    public Movie[] moviesDirectedBy(String arg) {
        List allMovies = finder.findAll();
        for (Iterator it = allMovies.iterator(); it.hasNext();) {
            Movie movie = (Movie) it.next();
            if (!movie.getDirector().equals(arg)) it.remove();
        }
        return (Movie[]) allMovies.toArray(new Movie[allMovies.size()]);
    }

The method moviesDirectedBy uses an interface:

public interface MovieFinder {
    List findAll();
}

Look at the MovieListener constructor. Martin argues that it’s a bad implementation because it ties the MovieListener class to a specific implementation of a MovieFinder. And he’s absolutely right. It’s pointless to have a MovieFinder interface if your code can only ever use one instance of it.

But this is not a new concept. This is the very basis of object-oriented programming. He may as well have called Dependency Injection “Non-Retarded Programming”. A non-retard implementation would probably contain this:

    public MovieLister(MovieFinder finder) {
        this.finder = finder;
    }

Which, low and behold, is exactly what he recommends. His example is nothing but a straw-man argument.

So my question to you is this: When did having a constructor that takes an argument become a new idea worthy of a new term? I wrote Java programs in 1996 that did this. C++ did it long before that. I mean good god, this idea is as old as object-oriented programming itself.

Now if you’re using the Spring framework, you might write some controlling XML not unlike the following:

<bean id="ColonDelimitedMovieFinder" class="org.kered.ColonDelimitedMovieFinder">
    <constructor-arg index="0" ref="movies1.txt"/>
</bean>
<bean id="MovieLister" class="org.kered.MovieLister">
    <constructor-arg index="0" ref="ColonDelimitedMovieFinder"/>
</bean>

And then the Spring controller would parse this XML, generate your objects, and offer some lookup service to some other code that uses MovieListener. But I ask you this: Why do you need a framework for that? How is this XML any less complicated than actual Java code that does the same thing? For example:

public class MyController {
  private static MovieFinder finder = new ColonDelimitedMovieFinder("movies1.txt");
  private static MovieListener listener = new MovieListener(finder);
  public static getMovieListener() { return listener; }
}

Presto – no framework needed! Plus, you’ve not given up compile-time validity checking of your code. (I love the “rename class” feature of Eclipse – too bad it breaks hard when all your inter-class ties are defined in XML configuration files. Back to using grep on every rename…)

Now, one might argue that the XML configuration gives you run-time flexibility in your architecture. That it allows non-programmers to configure your application in any way they please. But this is a fallacy. These XML configuration files *are* quasi-programming languages (interpreted ones at that). All you’re saving is the compile. You still have to be a programmer to modify them. It is no simpler than modifying the Java source code directly (or the bash/bat script that launches it). You’re simplifying nothing – only shifting the location of the complexity.

Ok Derek, yes, I can’t have my users editing the spring application context files themselves. But I still need to deploy multiple configurations of my architecture that vary significantly. How do I do that when it’s statically compiled?

Simple. Create multiple “controller” classes. (in a 1-to-1 parallel to whatever XML you would have to write anyway) Switch between them with runtime parameters, or a one-line configuration option. Again, Programming 101. And as a bonus, you get to fix the possible number of deployable configurations to a number that’s economically testable, and you prevent the setup of nonsensical configurations.

But Derek, in your example, “movies1.txt” is hard-coded into your program.

Yes, but “movies1.txt” is hard-coded into *both* examples. No application is going to instruct the user to modify that blob of XML either. Both systems would need an additional config file or gui somewhere to expose that option to the user.

To recap: I’m not saying dependency injection is crap. In fact I’ve apparently been programming it for over a decade. I’m just saying it’s a vacant term that offers nothing new to the field of computer science. And I’m saying that Spring’s XML configuration for dependency injection offers you virtually nothing in terms of ease of configuration (except for it being run-time interpreted, which you can get in a variety of simpler ways), and destroys one of Java’s greatest assets: strong compile time validity testing. (And if you don’t care about that, why are you using Java? Go learn Python!)

Update: Check out http://code.google.com/p/unsprung/.

while(c=System.in.read()>-1){
  System.out.print(backspaceChar);
}

Doesn’t do what you’d expect. (hide console input) It appears that System.in is being silently buffered.

So a little googling: http://java.sun.com/developer/technicalArticles/Security/pwordmask/

Sun’s recommendation is a busy-wait loop in a separate thread that constantly rewrites the previous character?!? I mean, seriously, WTF?!?

Edit: It looks like Sun implemented a new API for non-echoing prompts in v1.6: http://java.sun.com/javase/6/docs/api/java/io/Console.html

But this is still crappy. Introducing a new API to partially work around the broken functionality of an old API is how you get bloated monstrosities to begin with.

Here is the request:

<?xml version="1.0"?>
<SOAP-ENV:Envelope
 xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" >
  <SOAP-ENV:Body>
    <calculateFibonacci
      xmlns="http://namespaces.cafeconleche.org/xmljava/ch3/"
      type="xsi:positiveInteger">10</calculateFibonacci>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

Here is the response:

<?xml version="1.0"?>
<SOAP-ENV:Envelope
 xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" />
  <SOAP-ENV:Body>
    <Fibonacci_Numbers
      xmlns="http://namespaces.cafeconleche.org/xmljava/ch3/">
      <fibonacci index="1">1</fibonacci>
      <fibonacci index="2">1</fibonacci>
      <fibonacci index="3">2</fibonacci>
      <fibonacci index="4">3</fibonacci>
      <fibonacci index="5">5</fibonacci>
      <fibonacci index="6">8</fibonacci>
      <fibonacci index="7">13</fibonacci>
      <fibonacci index="8">21</fibonacci>
      <fibonacci index="9">34</fibonacci>
      <fibonacci index="10">55</fibonacci>
    </Fibonacci_Numbers>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

Dear $DEITY, why do we need to define a new data type to hold a list of integers? And what in the world is that “index” attribute doing there? IT’S A FUCKING LIST. This is like a real-life example of the old XML binary encoding joke:

<data>
  <binary>
    <bit index="0">0</bit>
    <bit index="1">0</bit>
    <bit index="2">1</bit>
    ...
    <bit index="n">1</bit>
  </binary>
</data>

It’s just sad…

For the sake of it, let’s compare to a JSON-RPC version: (not the epitome of efficiency mind you, but an order of magnitude better)

--> { "method": "calculateFibonacci", "params": [10,], "id": 1}
<-- { "result": [1,1,2,3,5,8,13,21,34,55], "error": null, "id": 1}

Which would you rather use?

So, to marry the two, I wrote for myself some wrapper code. It’s pretty much only good for one thing: multiplying large matrices together really fast. But it’s really good at it. (and it’s really easy to use) For example:

import numpy
from pycublas import CUBLASMatrix
A = CUBLASMatrix( numpy.mat([[1,2,3],[4,5,6]],numpy.float32) )
B = CUBLASMatrix( numpy.mat([[2,3],[4,5],[6,7]],numpy.float32) )
C = A*B
print C.np_mat()


All CUBLAS alloc and free calls are mapped to the CUBLASMatrix object’s life in Python, so you don’t have to worry about memory management. (other than filling up the card, or course)

Here are some performance numbers: (includes memory transfer times)
(4160×4160)*(4160×4160) = 43.0X faster than numpy
(4096×4096)*(4096×4096) = 34.0X
(3900×3900)*(3900×3900) = 47.3X
(2048×2048)*(2048×2048) = 28.2X
(1024×1024)*(1024×1024) = 58.8X
(512×512)*(512×512) = 24.1X
(256×256)*(256×256) = 6.3X
(128×128)*(128×128) = 1.1X
CPU: Intel(R) Core(TM)2 Duo CPU E8400 @ 3.00GHz stepping 06
GPU: nVidia Corporation GeForce 8800 GT (rev a2)

Note: This version only supports float32.
Note: CUBLAS limits matrix dims to (65536×65536).

Source code available here: pycublas.py (rename download to pycublas.py to use)

corpus = LDC2006T13()
for ngram, count in corpus.ngrams(3):
  print ngram, count


Code is here: LDC2006T13.py

Install the CUDA toolkit. Ubuntu already comes with the 177.80 NVidia driver, so I didn’t install v177.73.

# install CUDA
wget http://developer.download.nvidia.com/compute/cuda/2_0/linux/driver/NVIDIA-Linux-x86_64-177.73-pkg2.run
wget http://developer.download.nvidia.com/compute/cuda/2_0/linux/toolkit/NVIDIA_CUDA_Toolkit_2.0_ubuntu7.10_x86_64.run
wget http://developer.download.nvidia.com/compute/cuda/2_0/linux/sdk/NVIDIA_CUDA_SDK_2.02.0807.1535_linux.run
chmod +x *.run
sudo ./NVIDIA_CUDA_Toolkit_2.0_ubuntu7.10_x86_64.run
# accepted default install location: /usr/local/cuda
su -
echo "include /usr/local/cuda/lib" >> /etc/ld.so.conf.d/cuda.conf
ldconfig
cd /usr/bin/
ln -s /usr/local/cuda/open64/bin/* .
exit


Install Boost libs, v1.35.

sudo apt-get install libboost-python1.35-dev


Install PyCUDA.

wget http://pypi.python.org/packages/source/p/pycuda/pycuda-0.91.tar.gz#md5=339dac0641cc5da2f5c153d134592ed3
tar -zxvf pycuda-0.91.tar.gz
cd pycuda-0.91/
./configure


Edit siteconf.py to look like this…

BOOST_INC_DIR = ['/usr/include/boost/']
BOOST_LIB_DIR = ['/usr/lib']
BOOST_PYTHON_LIBNAME = ['boost_python-mt-py25']
CUDA_ROOT = '/usr/local/cuda/'
CUDADRV_LIB_DIR = []
CUDADRV_LIBNAME = ['cuda']
CXXFLAGS = []
LDFLAGS = []


Then take her home…

python setup.py build
sudo make install


Now to test:

#export C_INCLUDE_PATH=/usr/local/cuda/include/
#export CPLUS_INCLUDE_PATH=/usr/local/cuda/include/
export PATH=$PATH:/usr/local/cuda/bin/
cd test
python test_driver.py


The tests run successfully for me, sans test_mempool (__main__.TestCuda). I’ll update this as I find out more.

/* This is the format introduced and first used by Doug Paul.
   Optionally use a given symbol for the UNK word (id==0).
*/
/*
Format of the .arpabo file:
------------------------------

\data\
ngram 1=4989
ngram 2=835668
ngram 3=12345678

\1-grams:
...
-0.9792 ABC   -2.2031
...
log10_uniprob(ZWEIG)   ZWEIG   log10_alpha(ZWEIG)

\2-grams:
...
-0.8328 ABC DEFG -3.1234
...
log10_bo_biprob(WAS | ZWEIG)  ZWEIG  WAS   log10_bialpha(ZWEIG,WAS)

\3-grams:
...
-0.234 ABCD EFGHI JKL
...

\end\
*/

Note that it doesn’t require access the trac python libs or database; it just uses HTTP. But it does require BeautifulSoup. Install it by adding it to your hooks post-commit script. (it takes the normal params of REPOS and REV).

#!/usr/bin/env python

import os, re, sys, urllib, urllib2

from BeautifulSoup import BeautifulSoup

TRAC_URL = 'http://my.trac.url'
TRAC_TICKET_REL_URL = '/xxx/ticket/'
TRAC_LOGIN_REL_URL = '/xxx/login/'
TRAC_USER = 'user'
TRAC_PASS = 'pass'
TRAC_REALM = 'myRealm'
#SVNLOOK = '/usr/bin/svnlook'
SVNLOOK = '/usr/local/bin/svnlook'

TRAC_TICKET_URL = TRAC_URL+TRAC_TICKET_REL_URL
TRAC_LOGIN_URL = TRAC_URL+TRAC_LOGIN_REL_URL

def get_commit_info(repos, rev):
    c = os.popen( SVNLOOK+' info "%s" -r "%s"' % (repos, rev) )
    user = c.readline().strip()
    date = c.readline().strip()
    ignore = c.readline().strip()
    msg = c.read()
    c.close()
    return user, date, msg

def get_trac_tickets(msg):
    p = re.compile(r'trac:\d+')
    tickets = p.findall(msg)
    return [ t[5:] for t in tickets ]

def post_to_trac( ticket, msg ):
    auth = urllib2.HTTPDigestAuthHandler()
    auth.add_password(TRAC_REALM, TRAC_URL, TRAC_USER, TRAC_PASS)
    opener = urllib2.build_opener(auth, urllib2.HTTPCookieProcessor())
    req = urllib2.Request(TRAC_LOGIN_URL)
    req.add_header("Referer", TRAC_TICKET_URL+ticket)
    try:
        res = opener.open(req)
        html = res.read()
        soup = BeautifulSoup(html)
        form = soup.find('form', action=TRAC_TICKET_REL_URL+ticket+'#preview')
        data = {}
        for i in form.findAll('input'):
            try:
                if i['type']=='hidden' or i['type']=='text':
                    data[ i['name'] ] = i['value']
                if i['type']=='checkbox' or i['type']=='radio':
                    if i.get('checked'):
                        data[ i['name'] ] = i['value']
            except: pass
        for s in form.findAll('select'):
            for o in s.findAll('option'):
                if o.get('selected'):
                    data[ s['name'] ] = o.get('value',o.string)
        data['comment'] = msg
        #data['preview'] = 'Preview'
        #print '\n'.join([ str(x) for x in data.iteritems() ] )
        req = urllib2.Request(TRAC_TICKET_URL+ticket, urllib.urlencode(data))
        req.add_header("Referer", TRAC_TICKET_URL+ticket)
        res = opener.open(req)
        html = res.read()
        #print html

    except IOError, e:
        pass
#      if hasattr(e, 'code'):
#        if e.code != 401:
#            print 'We got another error'
#            print e.code
#        else:
#            print e.headers

def main(*args):

    if len(args)!=3:
        print 'usage: python commit-trac.py "repos" "rev"'
        return 1

    repos = args[1]
    rev = args[2]
    user, date, msg = get_commit_info(repos, rev)
    msg = 'svn commit to %s -r%s (%s):\n%s' % (repos, rev, user, msg)
    print msg

    for ticket in get_trac_tickets(msg):
        post_to_trac( ticket, msg )

    return 0 # exit errorlessly

if __name__ == '__main__':
    sys.exit(main(*sys.argv))