I hate learning a new technology by doing everything wrong the first time so I went looking for some best practices or architecture suggestions for setting up NHibernate. This book had an entire chapter on that and so I dove right in. Overall, it’s been very useful. Heavy use of Dependency Injection and Inversion of Control nicely decouple the pieces of the app from each other. However, the authors recommend something that seems a little extreme to me.

The example solution has a UI project which is the ASP.Net site, a Core project containing domain models and code, an Infrastructure project for things like data access and assorted test projects including an Integration Test project. The authors point out that the only project that references the Infrastructure project is the Integration Test project. Their rationale for this is that Infrastructure is necessarily fluid. Because of this, you don’t want to couple the core or UI to it. They set this up by using runtime DI to inject dependencies from the Infrastructure project into UI components. Specifically, the data access repositories that certain controllers need are discovered at runtime using settings in the web.config. They claim that this results in a completely decoupled application.

However, in order for this to work, the UI project needs to have access to the Infrastructure assemblies and config files. Normally, this would happen via an explicit reference in Visual Studio which would result in the necessary files being copied into the UI project at compile time. Because the UI project doesn’t have that reference, the authors have to get the files there another way. Their solution is to use a post build step in the Infrastructure project to copy the necessary files. To me, this only serves to make the reference implicit, something is likely to cause issues down the road.

The UI definitely has a dependency on the Infrastructure project. It seems extreme to hide that dependency in a post build step instead of showing it explicitly in the project references of the website. It’s one thing to write decoupled code that is easy to test and change. It’s entirely another to force developers to jump through hoops and keep track of idiosyncrasies like implicit project references. However, being a complete newbie to this form of architecture, maybe I’m missing something. Is there a true reason for managing dependencies between projects in this manner? If so, why not manage all of them in the same manner, do everything at runtime and copy all files via post build steps? I think the answer is that there isn’t a real reason for this except for the purity of the architecture, something that should immediately be questioned for intrinsic use. I’d love to hear any opinions from the experts out there.

1. Python 2.6 happily runs on Windows 64bit whatever but not all 3rd party libraries are so forward thinking. Specifically, if you’ve got a project using PostgreSQL and SqlAlchemy, SqlAlchemy will complain about the Python driver psycopg2 on 64bit systems. There are other drivers out there but my solution was just to rollback my 64bit installation of Python and reinstall a 32bit version. That seems to be working fine though I haven’t gotten to the point of actually reading and writing data yet.

2. PYTHONPATH on Windows via the registry doesn’t seem to work, at least on my Windows 7 64bit installation. I have added the required registry keys per the documentation, rebooted 42 times and done the Guido van Rossum Purple Rain Remix dance with exactly zero results. For now, I’m just creating an environment variable the old fashioned way.

3. The real problem that led me to having to modify PYTHONPATH was that package imports just don’t seem to be working. I’m sure this is me being the Python equivalent of Charlie in Flowers For Algernon. I think in the past I must have had some magical setting or batch file that modified PYTHONPATH at startup or something but I wish my subpackage imports worked without having to resort to that.

On the plus side, my first TDD test passed first time up so I’ve got that going for me, which is nice. At least the code isn’t so stale that it doesn’t even function anymore.

For those following along at home, you can get function keys to work on a Mac by going to System Preferences -> Keyboard and then checking the “Use F1, F2, etc as standard function keys.” I had done that early on and everything worked fine. Suddenly, last Friday, those keys started opening up the Start menu in Parallels and Finder on the Mac. Not good. So I started digging around and didn’t really run into much on the interwebs. I then decided to use my extensive Twitter network and luckily, with some long distance debugging, David O’Hara got me to the right solution which was to turn off the F Lock key on the Microsoft keyboard.

Somewhere along the way, I guess that I had managed to hit that key and what that did was disable function keys from the Microsoft keyboard’s perspective. When that happened, the “Use F1, F2, etc. . .” checkbox in System Preferences disappeared because Mac OS thought the keyboard didn’t support it. Even reinstalling the keyboard software didn’t help. Once I hit that key (which is dangerously close to the Backspace key in my unbalanced UI design opinion), all bets were off.

So if you are having trouble with function keys on a Mac, try toggling the F Lock key and quietly curse whoever thought it was a good idea to have a key that changed the behavior of 12 other keys. This is terrible UI design in my opinion, you should have to work to change something like that, i.e. put this in the control panel. There are also ways to disable it should you so choose.

The real problem is that I don’t completely understand what I’m not understanding. There is just a fuzzy, nagging feeling in the back of my brain that says “This can never work”, examples to the contrary notwithstanding. As a C# developer, I’m used to just modifying anything as necessary in my programs, adding values to lists, modifying dictionaries, randomly changing object values just to screw with people. Ok, maybe not that last part. But with Clojure, the world is very, very different.

Last login: Tue May  4 16:42:01 on ttys000
Bretts-Mac-Pro:~ admin$ clj
Clojure 1.1.0
user=> (def mylist '(1 2 3))
#'user/mylist
user=> mylist
(1 2 3)
user=> (cons 4 mylist)
(4 1 2 3)
user=> mylist
(1 2 3)
user=>

Here, I create a list, show the list at the command line, cons another number to the list and then show that the original list is unchanged. This takes some getting used to. Rich recommends the following when coming from an OO language:

In coming to Clojure from an OO language, you can use one of its persistent collections, e.g. maps, instead of objects. Use values as much as possible. And for those cases where your objects are truly modeling identities (far fewer cases than you might realize until you start thinking about it this way), you can use a Ref or Agent with e.g. a map as its state in order to model an identity with changing state.

Conceptually, I can think of a map of maps to model the world but I’ll be damned if I can really accept it right now. I understand the benefits behind the immutable data of Clojure but I look at my day to day programming tasks and just don’t see where it’s important. Maybe that’s just a failure of my imagination. I’m continuing to plug away on learning Clojure, trying to work my way into the Concurrency chapter of Stuart Halloway’s Programming Clojure which has been excellent.

I’m using the SyntaxHighlighter Evolved plugin which you can search for on the Plugins page of your WordPress installation. Install that plugin first.

Once that’s done, you’ll need to follow the directions for creating third party brushes for Syntax Highlighter. Specifically, you’re going to need to create your own plugin, which is pretty simple to do. Here’s what I did.

First, create a new folder in your plugins folder called clojurebrush. In that folder, create a php file with the following code (feel free to change the details at the top):

<?php
/*
Plugin Name: SyntaxHighlighter Evolved: Clojure Brush
Description: Adds support for the Clojure language to the SyntaxHighlighter Evolved plugin.
Author: Brett Bim
Version: 1.1.0
Author URI: http://yourblog.com/
*/

// SyntaxHighlighter Evolved doesn't do anything until early in the "init" hook, so best to wait until after that
add_action( 'init', 'syntaxhighlighter_clojure_regscript' );

// Tell SyntaxHighlighter Evolved about this new language/brush
add_filter( 'syntaxhighlighter_brushes', 'syntaxhighlighter_clojure_addlang' );

// Register the brush file with WordPress
function syntaxhighlighter_clojure_regscript() {
    wp_register_script( 'syntaxhighlighter-brush-clojure', plugins_url( 'shBrushClojure.js', __FILE__ ), array('syntaxhighlighter-core'));
}

// Filter SyntaxHighlighter Evolved's language array
function syntaxhighlighter_clojure_addlang( $brushes ) {
    $brushes['clojure'] = 'clojure';
    $brushes['clj'] = 'clojure';

    return $brushes;
}

?>

Note that this is the same file structure as the directions from the previous link with the exception of removing the version number from the wp_register_script() function call. That’s the thing that ate up a good chunk of my morning.

Once that’s done, you’ll need the JavaScript brush file for Clojure from Travis Whitton. Dump that into the clojurebrush folder that you created above. Go to your Plugins in WordPress and activate your new plugin. Once that’s done, you should have syntax highlighting in WordPress enabled.

Turns out, Firefox doesn’t like having tables’ styles set to “block” as a way to make them visible, ala the 10th post in this thread. So instead of doing this:

    function showCourseList()
		{
			document.getElementById('tblList').style.display = 'block';
			document.getElementById('tblTree').style.display = 'none';
			fixMoz();
		}

I did this instead:

    function showCourseList()
		{
			document.getElementById('tblList').style.display = '';
			document.getElementById('tblTree').style.display = 'none';
			fixMoz();
		}

This works not only in Firefox but all other major tested browsers which in my case is IE and Safari.

Making that realization got me thinking. I don’t much care for the feeling of 10 years of work that I can’t even refer to outside of a resume. Frankly, it’s a little depressing. So I’d like to make 2010 my year of hustle. I’d like to actually ship something that someone uses, a piece of software that I can at least be proud of. I’ve got a few ideas of things but one thing I struggle with is losing interest in a project. It would be generous to say that I’m a habitual project starter. I have shiny jangly disease and it manifests itself regularly. Part of the problem is that I thrive on feedback. I don’t need a lot of it but if I have to sit around working on something for a month with zero feedback, I’m going to lose interest. That happens a lot in my personal projects. So I’ve got to find a way around that.

One thing that would help is actually shipping pieces of something, something that could provide very definite and regular feedback. One idea is to create a main portal for my digital presence on the web. Currently, if you google me, you don’t even find this blog. You also don’t find my regular blog or my photoblog. I’d like to turn brettbim.com into a centralized portal for all my work, writing and photography. I’ve started playing around with that idea but the learning curve for designing something useful is pretty high for me, given the fact that I think WordPress would be the way to go. I have four WordPress blogs that get some level of regular attention so it seems like it would makes sense to use WordPress as the CMS for all my content. Problem is, when God was handing out designing skills, I was at recess. So I’ve got some learning there but then, I suppose that’s the point of having a year of hustle.

I have a few other very nebulous ideas that could be done in a year. I need to spend some time fleshing them out. I know I’m not particularly thrilled with how my work life has played out over the last 10 years. Much of what I’ve done has been low on the creativity scale and that is a big drain. I got into programming because it was a way to exercise my brain on a regular basis and exercise my need for creativity. As it turns out, most programming in corporate environments does neither. I’ve been lucky over the past few years to be in jobs that really stretched my mental capacity including my current job but the creativity always seems to be missing.

I’m not really sure what a year of hustle will look like for me. I think the best thing I could do would be to just start throwing stuff out there and see what sticks. My life has been changing in quite a few ways lately so we might as well go full out. I’d like to ship one thing this year at the very least. We’ll set the bar low and see what happens.

We decided to change that to a CheckBoxList for each filter. This removes one step and makes the UI a little more fluid. However, it did cause one problem. Previously, the ListBoxes were being loaded with data on PageLoad by just adding a new ListItem for each piece of data. This works well because the ListItem can hold whatever value you want to key off of. However, a CheckBoxList renders as a table of CheckBoxes, none of which have the ability to hold a piece of data to key off of.

    protected void Page_Load(object sender, EventArgs e)
    {
        if (!Page.IsPostBack)
        {
            for(int x = 0; x < 3; x++)
            {
                MyListBox.Items.Add(new ListItem("my value is " + x, x.ToString()));
            }
        }
    }

That code rendered a ListBox that had source like this:

my value is 0
my value is 1
my value is 2

From there, it was really easy to grab the value of any selections via JavaScript. Unfortunately, as mentioned above, the CheckBoxList does not render that way. Using the same code in the PageLoad ends up rendering this HTML:

my value is 0



my value is 1



my value is 2

As you can see, none of the checkboxes have the value attribute. There is now a label for each one but it has the Key of the ListItem and not the Value which isn't particularly helpful when you want to display one piece of data for the user but process another one based on their selection. What to do?

As it turns out, you can add an attribute that gets rendered as a span around both the input and label elements. In JavaScript, you can then grab an array of the inputs and an array of the span elements. When one of the input boxes is found to be checked, you can get the corresponding span element's attribute and use it. It looks a little something like this:

    protected void Page_Load(object sender, EventArgs e)
    {
        if (!Page.IsPostBack)
        {
            for(int x = 0; x < 3; x++)
            {
                ListItem li = new ListItem {Text = "my value is " + x, Value = x.ToString()};
                li.Attributes.Add("myspecialid", x.ToString());
                MyCheckBoxList.Items.Add(li);
            }
        }
    }

When the items are loaded into the ListItems, we add an attribute called "myspecialid". It can be anything you want though it doesn't work if you pick a known attribute like id or value. Once that's done, the HTML renders like this:

my value is 0



my value is 1



my value is 2

Our new attribute has been included in a span tag around the input element and the value we want to track is included there. Now in JavaScript, we can do this:

function DoSomething() {
    var tableBody = document.getElementById("Tabstrip1_StudentsTab_MyCheckBoxList");
    var inputArray = tableBody.getElementsByTagName("input");
    var spanArray = tableBody.getElementsByTagName("span");
    for (var x = 0; x < inputArray.length; x++) {
        if (inputArray[x].checked) {
            alert("The id I want is " + spanArray[x].getAttribute("myspecialid"));
        }
    }
    if (groupsSelected.length > 0) {
        __aspx.HandleMonitorGroupFilter(groupsSelected);
    }
}

We grab all the input and span elements in the table. Then when we find a checkbox that is checked, we can grab the attribute we're interested in off of the appropriate span element using the getAttribute method. This is slightly hackish in that the two arrays of elements have to be in the same order but that seems like a reasonably safe assumption to make.

Overall, it seems like a good way to make the UI more fluid while still retaining the ability to manipulate necessary data on the AJAX calls.

What does this have to do with Internet Explorer? From the post:

Unfortunately, we weren’t able to make this work in Internet Explorer, so to see the speed-up, you’ll need to be using Mozilla Firefox, Apple’s Safari, or Google Chrome.

Not to go all conspiracy theorist on your ass but how hard do you think they really tried? Can’t you just see the engineers sitting around the conference table discussing this when Bob says “Wouldn’t it be cool if we just didn’t implement this for IE?” I just find it hard to believe that the geniuses at Google couldn’t come up with a way to make this work in IE. Maybe there really are some technological limitations that my puny brain can’t possibly handle but it’s a way better story if they just didn’t bother to try. Not that I’m complaining, I’d barely use IE if it was the last browser on earth after a nuclear holocaust.

Today, for some reason, I couldn’t log in remotely to the MySql instance running on my Mac. This has been working just fine for the past month so needless to say, I had no idea what happened. As it turned out, the IP address of my Parallels instance had changed, rendering all the entries in my user table pointless. I had to update the user table with the new IP, restart the MySql instance and boom, up and running again.

Login from the terminal first:

mysql -u root -p

Then:

USE mysql; 

select Host, User from user;

update user Set Host = 'NEW IP' where Host = 'OLD IP';

select Host, User from user;