Ryan Brubaker

Water Rocket

2011-08-14T19:25:00.001-07:00

My son Max turned 4 yesterday. We had a rocket-themed birthday party for him so I found some instructions on the internet on how to make a water rocket. I'm not much of a handy man but this looked like an easy enough project. The results were somewhat disappointing for me, but luckily 4 year old boys are pretty easily impressed and it was a pretty big hit:
Launch I
Launch II

It looks like the seal at the mouth of the water bottle needed to be tighter and we were going a little overboard on the air pressure. The seal at the top was formed by heating up the PVC pipe with a candle until it became flexible, then pushing inward on both sides to create a bulge. The bulge I made was off to the side a little bit so I'm not surprised that caused a problem. I think if we could have figured out just the right amount of air pressure before it broke the seal we could have gotten a pretty decent launch. So I'm hoping to use it again in the near future to see if we can get better results. If we can't, it was easy enough to make that I'd like to try again, maybe when Max is a little older and can help build it.

Overall it was a fun experience and educational. It definitely made me want to find other projects to work on.

30 Days to Success 1.1

2011-08-10T20:13:00.000-07:00

On Monday, Apple approved the new version of my iPhone app, 30 Days to Success. The new version doesn't contain anything too compelling:

Added functionality to restore application state at launch.

Updated application to only retrieve user Facebook info as necessary.

Added nicer view for Facebook Wall of Fame page.

Added functionality to share the application link with email contacts.

Added a friendly reminder to provide a review for the application.

Fixed some minor bugs.

I added the reminder to review the application using Appirater and integrated Facebook's Three20 library to make a much better view of the Wall of Fame. Adding state restoration was a bit of a pain but I figure if I'm going to charge for my app, I need to add little niceties like that.

I also updated how I retrieved user Facebook information. To post to the app's Facebook page, the user must "like" my Facebook app. Because the user might like/unlike the app, I need to make sure I have the latest info and prompt them accordingly if they try to post one of their successful trials to my app's page. Because it was easier on me, I was retrieving that information when the app started up. But that was a sub-optimal user experience as that information only is needed when posting to the app page. So that was a needed change as I was putting myself ahead of the user.

For my next update, I plan on adding functionality for users to suggest potential trials. I'm going to create a small set of web services on Google App engine that will allow users to submit a trial suggestion, email me a notification so I can review the suggestion and then return the list of suggestions to the app.

Javascript closures

2011-06-28T18:13:00.000-07:00

A couple of days ago, there was a thread on Hacker News regarding Javascript closures. The thread referenced a question on Stack Overflow asking how best to explain closures. I'm not going to try and explain them here, but instead describe when the light bulb finally went off in my head regarding closures.

For one of my web app projects, I needed a small component to display the number of characters being typed into a text field (a la Twitter). Unfortunately, I didn't think to check for any existing jQuery plugins for such functionality as there are quite a few. Fortunately, I just rolled my own and in the process finally realized the power of closures.

My implementation turned out to be:



this.AddCharacterCounter = function(textField, counterField, characterLimit)
{
   var updateCounter = function()
   {
      // All the code here to count characters and set css styles
      // based on whether or not the limit had been reached.
   };

   var handleKeyEvent = function(event)
   {
      updateCounter(textField, counterField, characterLimit);
   };

   textField.keydown(handleKeyEvent);
   textField.keyup(handleKeyEvent);
   updateCounter();
}

Then for any field that I wanted to attach such a counter, I just had to do the following:



that.AddCharacterCounter($('#field1'), $('#field1Counter'), 300);
that.AddCharacterCounter($('#field2'), $('#field2Counter'), 150);
that.AddCharacterCounter($('#field3'), $('#field3Counter'), 30);

Project Management: UI

2011-06-27T19:37:00.000-07:00

One thing I struggle with both as a developer and PM is UI. There are two particular examples for my history as a PM.

The first project was for an iPhone app where the client asked us to take their comps and make them more iPhone-friendly. Our designer took their concepts and made what I thought was a much cleaner, usable interface. Unfortunately the client didn't like the design and we went through several more iterations of updates, each side getting more and more frustrated as our ideas weren't converging. In the end it became obvious that the client always wanted their original concept/layout but were just looking for us to create nicer UI assets for the implementation.

The other project was a web application in which the client was extremely picky about the web site matching their comps pixel-for-pixel. The client did come up with a very nice design and provided us with very detailed comps so their pickiness wasn't completely unwarranted. As a PM and someone who doesn't easily pick up on UI design issues, I did not do a good job of vetting our implementation of the design before sending it on to the client. As a result a lot of time was wasted in back-and-forth communication to work out small UI mismatches.

So how could I have avoided these situations? In the first case I think it was mainly a matter of communication. I interpreted the client's instructions as giving us free reign to generate a completely different implementation of the client's concepts. In the future I will make a point to thoroughly discuss with the client what they are looking for when asking us to do UI work.

In the second case I think it's just becoming more aware of UI issues in general. It was obvious from the start that the client didn't want much/any deviation from their comps. But the web application was packed with functionality and as a developer, functionality is what I find interesting. In contrast, I can't just look at a label and tell what its font styles are and if they match the styles in a comp. In the future, I think I just need to consciously check for these type of issues, along with learning/practicing more design in my own side projects. I will also be more aware that a client that gives us detailed comps will probably be particular about how those comps are implemented.

One other step that I think would help in such a case is getting the general HTML/CSS layout in place and signed off by the client before beginning to implement any major functionality. Such a workflow would really make HTML/CSS changes easier rather than trying to force-fit changes later on in the project.

The folks at Herding Code recently had a very interesting podcast on situations like the second project I described here.

Project Management: Project History

2011-06-23T20:44:00.000-07:00

One thing I wish I had done better on my current project is to keep track of decisions that were made throughout the project. Multiple requirements have been changed multiple times and have just become more complicated throughout the process. It would be nice if there was a one-stop place where I could go to review past changes/decisions and why they were made to better make sense of new change requests. Yes, most decisions can be retrieved by searching through email but I'd like something that I can just pull up and quickly glance over, digging down deeper if necessary.

So for future projects I'm planning on keeping a project journal to try and capture this information. I am going to focus on feature-level decisions as I can track task-level changes within our internal task system.

At first I was thinking that a wiki would be a good place to track this information, but I'm going to create a journal document within our internal collaboration system, FirstClass. Using a document will be pretty convenient since I can drag/drop emails into the document to create links back to the conversation threads where changes were discussed and approved. These links will then serve as a way for me to dig down deeper to revisit past changes and as a gentle reminder to clients of the change requests that were made during the project.

2011-06-22T21:20:00.000-07:00

TO B.R. HAYDON, ESQ.

High is our calling, Friend!--Creative Art
(Whether the instrument of words she use,
Or pencil pregnant with ethereal hues),
Demands the service of a mind and heart,
Heroically fashioned--to infuse
Faith in the whispers of the lonely Muse,
While the whole world seems adverse to desert:
And, oh! when Nature sinks, as oft she may,
Through long-lived pressure of obscure distress,
Still to be strenuous for the bright reward,
And in the soul admit of no decay--
Brook no continuance of weak-mindedness:
Great is the glory, for the strife is hard!

William Wordsworth

Project Management: People

2011-06-21T20:15:00.000-07:00

One of my favorite blogs is Rands In Repose. Rands is the only person I've ever read that makes project management sound both fun and challenging. He really seems to be able to get into the heads of people and understand what makes them tick. While reading his book Being Geek, I thought to myself that I would really enjoy the challenge of being a full-time project manager in the future (there's always time to write code in my off hours...just ask my wife ). But I don't think I'm at that point yet as I'm not ready to give up writing code during my day job.

One area of project management that Rands focuses on is managing people. At Art & Logic, I have the luxury of focusing most of my energies on the project. I'm not responsible for managing anyone's career path or filling out yearly evaluations. It's basically a matter of defining and doling out tasks. I do my best to try and match developers with tasks in which they have genuine interest, but that isn't too difficult given the unique types of projects we get.

One interesting aspect of project management at Art & Logic is that I'm always managing new people. Part of me enjoys the opportunity to work with new people. At the same time, it would be nice to gel with a consistent team of people and developer deeper relationships. But it really seems to be the nature of consulting where projects come and go much quicker and it's necessary to match the project with people having the appropriate skills.

But again, I'm thinking that it might be fun in the future to work for a product company and manage a team of developers on a commercial product. It would definitely be a new challenge to be responsible for a single product and a single team. I also think it would be fun to be more of a mentor and help people along their paths to become better developers.

Project Management: Time

2011-06-20T19:28:00.000-07:00

Art & Logic bills on a time and materials basis. This is a good thing, but as a project manager I often struggle with the thought that every hour I spend on PM tasks is an hour I take away from developers to get the real work done. At the same time, an hour spent on PM tasks could prevent countless hours of wasted time later on in the project due to a miscommunication/misunderstand of requirements.

It's quite a balancing act to find that right level of involvement where you have all of the details that you need, while still squeezing out as many hours as possible for the developers. I like to think I've found that balance, though I tend to be a little more hands-off due to being a developer myself. I understand the negative impacts of interruptions and what it does to flow-state. So far this method has served me well and I think that's due to the following reasons:

I work with a great group of developers that can take a task and complete it with minimal direction.

I'm very detail-oriented, so even though I try to limit the hours I use as a PM, I have the complete picture of the project in front of me in my GTD system.

A more "hands-off" approach fits with the JUST-SUFFICIENCY model stated in Art & Logic's development manifesto. An example of this in my PM style is to limit the project's tasklist to the features/tasks that are in the immediate future instead of populating the tasklist with the entire set of requirements at the beginning of the project. It's a given that many of those requirements will be changed/removed before the project comes to a close.

Another factor that comes into play is the type and size of the project. A small iPhone application does not demand the type of attention that a large web application does.

I'm constantly tweaking how I do things and am hopefully improving with each project. My ultimate goal is to continue improving the efficiency of my workflow as a PM, enabling me to get more information about projects in less time.

Next Few Posts

2011-06-18T20:53:00.001-07:00

It's late so I'm going to cheat a little bit tonight and make a meta-post about my upcoming posts. When I started my job as a consultant at Art & Logic, I came in expecting to write code a majority of my working hours. After a couple of projects, it became clear that client/project management was also a pretty big part of the job, especially when working as a solo developer on a project.

Over the past year and a half, I've had the opportunity to manage teams of people on some pretty large projects. Before I started at Art and Logic, had you told me I'd be a project manager, I would have asked you to put me out of my misery now. My thoughts on project management/managers were too similar to Dilbert cartoons.

However, I've really enjoyed learning project management and I feel that I'm getting better at it each project. My next couple of posts will talk about some of the experiences I've had and lessons learned while starting out in this new role.

Beginner JavaScript Trick

2011-06-17T20:40:00.000-07:00

So this trick is probably old-hat for any experienced JavaScript programmer, but the problem it solves tripped me up when I first started using JavaScript in depth. I was maintaining code written by another developer and at the beginning of every JavaScript module he wrote he would always have the following line:


var that = this;

I didn't really understand the point of it at the time until I later ran into a frustrating bug where this wasn't pointing to the (top-level) object I thought it should. Sure enough, it was because I was referring to this within an event handler and this was pointing to the target of the event rather than the top-level object. The light bulb went off in my head. So whenever you want to refer to your top-level object, you can just reference that and use this everywhere else. This article provides a good explanation of the issue.

Sometime later, I was watching Douglas Crockford's JavaScript lectures on Yahoo and saw that he uses the same technique. Unfortunately, those videos are no longer available on Yahoo.

Software project ideas

2011-06-16T20:21:00.000-07:00

While testing my new iPhone app, I completed a 7-day trial to brainstorm three new mobile app ideas per day. When Apple says "there's an app for that" they're not kidding. Coming up with an original idea is pretty close to impossible. I wasn't limiting myself to original ideas and even searched the the app store to see if there were any ideas I could improve on. But any simple ideas have likely been done.

For example, on the weekend of my trial, Max and I camped out at my in-laws and we toasted marshmallows. "Aha!" I thought. That would be a good gimmicky app (I was going for quantity here, not quality). Searching for marshmallow on the app store didn't turn up anything. But the next day it hit me I didn't search for s'mores and sure enough...there's an app for that.

I did think of a couple of apps that don't seem to be in the store but they would require nice graphics and I'm not looking to do anything where I'd have to hire someone to do that work.

By far the ideas I thought were best were apps for existing companies/entities to supplement their current offerings. I have several ideas now for apps for local businesses/friends . When I get some free time I'm definitely planning on approaching some people to see if they're interested.

30 Days to Success

2011-06-15T20:26:00.000-07:00

This week Apple approved my iPhone app 30 Days to Success, which is an application based on Steve Pavlina's article of the same name.

I've had the idea for this app for several years now and actually developed a prototype 2 years ago. I emailed Steve to see if he would be interested in the app but he declined. So I dropped the idea not wanting to infringe on his copyrights.

But late last year Steve released all copyrights to his online content so I decided to start the project back up.

Back in the prototype phase, I had created my own hideous calendar UI. After stopping work on the project, I ran across the Kal library when doing some estimates at my day job and and knew that was something I would have to integrate. So with a better looking UI and some updates to integrate Facebook and Twitter, I thought I had something that was worthy of release. There are a couple of things I'm still not happy with but I will fix them over time.

I'm not expecting too much income from the app although I'm hoping to make a little bit of passive income off of it in the long run. I think I have a couple of things going for me:
- I can take advantage of Steve Pavlina's already large audience.
- Integration of Facebook and Twitter will put the app in front of a lot more eyes.
- I'm planning some other social features that should encourage current users to get others involved with the app.

I had one sale the first day and two sales the second day. Assuming this exponential growth rate continues, I'll be at a million sales in no time :)

Day 1 of 30

2011-06-14T19:34:00.000-07:00

In honor of the release of my new iPhone app to the iTunes store, I am going to try and complete a 30 day trial to write something here every day.

I've queued up about 10 topics I'd like to write about so I should be good to go for at least the first week and a half.

And with that, Day 1 is a success ;)

New Hobby

2010-09-21T19:24:00.000-07:00

One of my favorite classes in college was the Digital Logic class where we had to design basic computer circuitry. Then this year I read Code: The Hidden Language of Computer Hardware and Software and again, was just engrossed in all of the gates, adders and multiplexers. I really am clueless when it comes to a lot of this stuff but always wanted to get some hands-on experience.

I first found about the Arduino project from the July 2010 issue of PragPub. Then a couple of weeks ago, a friend of mine mentioned that he bought an Arduino and was fooling around with it so I decided to take the plunge too.

Like my friend, I ended up purchasing the SparkFun Inventor's Kit for Arduino, which comes with some basic parts and project schema to get you started.

Here is a video of my son and I with our first project to light up some LEDs:

New Home Page

2010-09-19T20:52:00.001-07:00

I've been doing a lot of work on Google App Engine lately and finally registered a domain name for myself at ryan-brubaker.com. It's probably a little bit of overkill to use GAE for a personal site but I just find it easier. I'm going to use that page to start putting up code samples, keep track of books I've read and anything else that strikes my fancy.

I'll still be using blogger to host my blog, which after a year of silence, I hope to get back on track again. This past year has been a busy year for me and I have a lot of things I'd like to write about.

And for a little vanity note, I'm now listed on the Developer Testimonials page on the Art & Logic website: Art & Logic Careers (click the Developer Testimonials tab).

Coming Up for Air

2009-08-22T20:27:00.000-07:00

So much for posting once a month...

I've been extremely busy in my life lately, mostly due to work, which is a good thing given the state of the economy. But I'm finally seeing the light at the end of the tunnel and I think my schedule will be a little more normal in the coming weeks.

July was my one year anniversary at Art & Logic. And what a year! I've worked on 13 different projects throughout the past year, all of which I've really enjoyed. I've programmed in C++, Java, Objective C, ActionScript3/Flex, Javascript and C# (including ASP.net). I've written desktop programs, BlackBerry apps, iPhone apps (2 in the store, 1 pending approval, and some others still in progress) and a web application targeting the iPhone (and BlackBerry in the near future).
Needless to say, I'm having a blast and working as a consultant is providing me the variety I crave in a job.

One of my most recent projects, hinted at above, is an ASP.net application targeting the iPhone and BlackBerry platforms. This was my first production-level web application, although I've spent a little time on my own learning Ruby on Rails and a little bit of time at work learning TurboGears. It's been a lot of fun, and I was surprised at how much I enjoyed using ASP.net.

What I've realized during this project though, is that I really need to come up to speed on Javascript/CSS. This project was small enough that I didn't run into too many issues, but if I want to continue doing web applications (and I do), I really need a more thorough knowledge of those two technologies. I'm planning on buying some books in the near future that should hopefully give me the basics I need to build a stronger knowledge base.

I'm also hoping to provide some updates to the Grader program I developed for my brother. The deadline on that is pretty tight as his football season is rapidly approaching. So there may be a couple of late nights for me coming up in the near future.

One other project I have in mind is a simple application written on top of the Google app engine. I am a secretary for a local organization, and I'd like to create a web application that allows people to submit information to me, aggregate it, and resend it out to concerned parties. Sifting through separate emails to gather the information and compose a new email is taking up too much of my time. And it's another chance to get some web development experience.

Code Kata and Learning Math have been on hold for quite a while, but I'm hoping to get those back on track also.

Code Kata

2009-01-28T19:26:00.000-08:00

One of my goals for quite a while has been starting a Code Kata practice. Dave Thomas nicely sums up the benefits of such a habit at the above link. However, there are several other reasons I want to start this practice, all of which fall under the category of becoming a better programmer, but which have materialized after starting my job as a consultant. The main factor in recognizing these areas in which I'd like to improve, has been working within very aggressive budgets (time-wise) that don't allow much time to stray from the well-beaten path.

Good Programmers Write Good Code; Great Programmers Steal Great Code
One consequence of aggressive budgets is that it usually makes sense to find existing code that does what you need it to do, rather than writing it from scratch. Between sample code in documentation, generic code from previous projects and personal blog posts, it's almost impossible not to be able to find existing code that at least points you in the direction you need to go.

Unfortunately, I think this has somewhat diminished my ability to quickly solve problems on my own. I want to use the Code Kata practice to plop myself in front of a blank editor and pull the code out of my head.

Unit Testing
Ever since taking a TDD course taught by Robert Martin, I've wanted the same experience I had in his class in my daily programming activities. Having a suite of tests to run after each code change and seeing those tests pass was very gratifying. Even more gratifying was changing the code, seeing an error, and knowing exactly where and why that error occurred because of the tests we had in place.

Most of my projects so far as a consultant haven't been very business-rule intensive. So the model objects in the code were pretty simple and the projects wouldn't have benefited that much from a unit-test suite.

The problem is, even if unit tests would have been useful, I don't have enough experience with the standard testing tools to quickly integrate them into a project without wasting valuable budget time.

I want to use the Code Kata practice to learn the different testing tools that exist, including tools that test at a higher level than a unit. I'm also hoping to get better at understanding what to test and how to write better tests.

Learning new tools/libraries/languages/specialty areas
This last point is similar to the previous one, but I also want to expand my tool set in other areas. One example is becoming an expert in a standard editor that I would use across languages in order to increase my efficiency in editor use. Another example, is focusing the Code Kata practice on an area such as Artificial Intelligence or Image Processing for a set amount of time.

Next Steps
The biggest problem in getting into this habit, like any habit really, is finding the time to do it. I know I will not be able to follow a set schedule so I will just have to be disciplined enough to dedicate some time to it every few weeks. Hopefully, posting on this blog will give me a way to stay accountable.

My first practice will be to review The C Programming Language. I already know C, but I think it will be a good way to review and give myself the pleasure of making some fast progress when I start. It certainly won't hurt to reinforce some of the basics again. And it will also give me some easy programs for unit testing, allowing some quick progress on that front.

The other thing I'd like to do during this first practice, is to learn Emacs and eventually use it as my standard editor. This will likely take quite a bit of time, but I need to start sometime. But again, it will help to start out small, reviewing a language I already know instead of taking on too many new areas at once.

iPhone SDK : UIWebView

2009-01-05T17:58:00.000-08:00

I've been tangling with UIWebView the past couple of days and am documenting my struggles in hopes that this post may save others some time in the future. I've found a solution to my problem, intercepting single-tap events that occur on a UIWebView, although the solution doesn't seem to be optimal. But first, a little background to the other approaches I've tried...

Subclassing UIWebView/Overlaying a Transparent UIView

These approaches are basically the same. In a UIWebView subclass or in a transparent UIView subclass (on top of a UIWebView), override the UIResponder methods (touchesBegan:withEvent, touchesMoved:withEvent, etc...) and handle the touches accordingly.

The catch here for me was that I really wanted the UIWebView to behave as it always did for any other events. This would suggest that I just needed to intercept any single-tap events, and afterwards, forward all events to the UIWebView. However, what you really need to do is forward the events to the UiWebView's immediate subview, which is an instance of UIScroller. This solution seemed like it would work until I realized that pinch zoom events no longer worked and they are essential to the application I'm building.

Even more frustrating is the fact that all of UIWebView's subviews are not part of the public SDK. This fact makes it pretty much impossible to programmatically change how UIWebView works under the covers.

For more information on this approach, see the following thread in the Apple developer forums.

Overriding UIView hitTest:withEventmethod

According to Kerem at CodingVentures, he was able to intercept double-tap events on a UIWebView by subclassing and overriding the hitTest:withEvent method. However, when I implemented this technique, the UIEvent passed into the method always had an empty set of touches making it impossible to get the tapCount property on any UITouch objects. I tried overriding hitTest:withEvent for other UIView controls (e.g UIWindow, UIScrollView, etc...) all with the same result.

My Solution

The solution I came up with was to subclass UIWindow and override the sendEvent: method. This method gets called after hitTest:sendEvent returns but before any of the UIResponder methods get called. At this point, the UIEvent contains all of the associated touches, allowing me to access the tapCount property of the associated UITouch objects.

This solution isn't perfect as I am now handling single-taps at the window level instead of just those that occur on the UIWebView. Luckily, this doesn't really interfere with what I'm trying to do in my application.

I'd still really like to know why it seems that someimes the UIEvent passed into hitTest:sendEvent has touches associated with it and sometimes doesn't. I'd also be interested if anyone can successfully forward on pinch events to UIWebView.

This and That

2009-01-02T19:20:00.000-08:00

I was able to clear my plate of several things at year's end and am looking to a fresh start to the new year.

Job

My job is still going really well and I'm very happy with the decision I made to join Art & Logic. I've learned so much over the past half year and see that continuing into the new year. A project I completed for M Financial Group is now featured on our website as it was the first native Blackberry application completed by our company. My current project is for the iPhone and should be completed early this year.

Math

I finally completed the algebra book I started earlier this year. I have a bad habit of not quitting books I've started, even if I've decided they aren't that interesting or helpful. I probably didn't need to go through this whole book as it was pretty basic stuff. But it was a good refresher and a confidence booster that I haven't forgotten all of the math I've ever learned. The next math book I'm planning to tackle is Matrix Analysis and Applied Linear Algebra, which I know will be more challenging and should provide more value.

Grader

My brother asked for some updates to this program, namely the ability to save application session state. So I am going to add an sqlite backend to add the ability to save/reload the program data and hopefully refactor the code a little bit. I've switched over to a Macbook as my primary development machine and finally got all of the software downloaded/installed to my VirtualBox Windows image for this project. I had been using Eclipse's CDT plugin to develop this app but I'm going to switch over to Visual Studio Express since it's free.

Code Kata

I am going to write a post in the near future about how I'm planning on starting this development practice.

Blogging

I set a goal to write a post on this blog at least once a month this year. But I'm going to try and do more than that if I can.

It's Been a While...

2008-08-31T20:11:00.000-07:00

since I wrote anything here, but that's mainly because I've been focused on finishing up the work for my Master's degree. And I'm happy to say that everything has been completed except for a few touch-up edits to my final paper. I'm very relieved that this process is over and I'm looking forward to evenings where I can choose to do whatever I want, or at least choose to do whatever I want without feeling guilty about procrastinating on my project :)

So what am I going to do? As far as software development is concerned my goals are the following:

Establish a regular Code Kata practice.
Continue learning math.
Add some more features to Grader that my brother requested and convert it into a web application using Ruby on Rails.
Establish a consistent GTD system.

Following through on these goals should also give me plenty of material to regularly post to this blog.

Of course, all of these goals are secondary to performing at my current job, which has been absolutely great so far. I finished up my first project about a month ago, released a cut of my second project today, and should be starting my third project in a couple of days. Each project has required me to work with a new programming language and/or work with a very interesting 3rd party API. Working from home has take some getting used to, but I'm definitely able to concentrate better and feel that my productivity has significantly increased.

I'm really looking forward to this time in my life and feel that completing my degree now affords me time to really concentrate on becoming a better developer.

New Job

2008-07-01T20:49:00.001-07:00

On Thursday, July 10th, I will be starting a new job with Art & Logic. I'm very excited about this career change and can't wait to start.

Leaving my current job was both an easy decision a and hard decision to make. I really like the people I work with and will miss the camaraderie our team shared. I'm also leaving right in the middle of a large project so the timing isn't the best. But finding the perfect time to leave is probably impossible.

With that said, I feel very confident I'm making the correct long-term decision. I've worked for my current employer for over seven years, the last four years working on the same project. One of my favorite things about programming is that it requires a constant effort to learn new languages, skills and techniques and I feel that my current position was lacking in this area. I work in a very mature industry with little opportunity for innovation. Programming has become somewhat stale for me over the past few months, and to me, that signals a need for change. Spending nine hours a day at a job that just isn't fun anymore does a disservice to myself, my family and the rest of my team.

My new job should remedy the problems I stated above. It's a contracting position so I'm looking forward to the variety of projects and challenges I will face. I already feel rejuvenated when it comes to writing code and am ready to jump headfirst into my first project. I will also be working out of my home, which I'm sure will pose a new set of challenges for me and my family. But the thought of escaping the cube farm and working in an environment where it will be much easier to reach a flow-state, is very satisfying. There are some potential downsides to working as a contractor, but I'm not too concerned about them at this point. I'm really just excited about the chance at a fresh start and the opportunities that lie ahead.

Book Review: Out of their Minds: The Lives and Discoveries of 15 Great Computer Scientists

2008-04-19T19:41:00.000-07:00

I'm on a roll in the book department.

As its title implies, this book presents 15 major figures (e.g. Dijkstra, Knuth, McCarthy) in computer science history and some of their most important discoveries. It was a very interesting, humbling, and motivating read. It's amazing to think of what these men discovered without the high level languages and modern hardware that is available today. Had I grown up in their generation, I doubt I would have pursued a career in software. Although I enjoyed my assembly language class in college, one semester was enough. Although I am obviously not on the same intellectual plane as the subjects of the book, reading about their accomplishments was inspiration enough to continue becoming a better developer and expanding my knowledge about computer science.

Two other things that jumped out at me when reading this book:

It was interesting to see that many of these men started their careers (or academic careers) in something other than computer science. From biology, to music, to chemistry, most of them were proficient in some other field before ending up in their final career path. What they all had in common though, was a passion for creating things, which easily transferred into the computer science field.
Reading this book made me wonder why college computer science programs (at least mine) do not have a History of Computer Science class where these men and their discoveries are the focus of the course. I think many students would gain an appreciation for the history behind the major discoveries in the field, along with the same motivation I received from reading the book. It would also make students appreciate the work and dedication required to become an expert in the field.

Book Review: Tog on Software Design

2008-04-13T19:02:00.001-07:00

I just finished reading Tog on Software Design, a very interesting book overall, although I found some parts a little more interesting than others.

Much of the focus of the book is on Bruce Tognazzi's Starfire project, a project started in 1992 to provide a vision of the future for software in the year 2004. The transcripts of the resulting video from the project were a little tedious to get through...I should have just watched the video. It was interesting to see how much of the technology featured in the video still isn't available four years after the story takes place.

The rest of the book focused on design principles intended to provide a better user experience when creating software. Many of the principles he presented were simple matter of fact statements that seemed obvious. But turning his principles into implementations are probably easier said than done.

The part of the book I found most interesting was his side-by-side comparison of software and magic. It is an interesting metaphor that doesn't seem very obvious, but makes a lot of sense after his explanation. To summarize:

Both software designers and magicians create virtual realities. We bring ours alive on computer displays; magicians bring theirs alive on the stage. We capture our "performances" in code so they can continue to occur long after their writing; magicians traditionally appear live. We depend on our knowledge of the mechanics of computer technology, the aesthetics of graphic design, and the science of psychology. Magicians depend on their knowledge of the mechanics of their tricks, the aesthetics of showmanship, and the science of psychology.

It's interesting to envision the goal of software design as providing a user with an illusion that makes the physical computer disappear and replaces it with a real world metaphor that allows them to get work done.

Learning Math

2008-04-12T18:26:00.001-07:00

Inspired by this post from Steve Yegge, I have decided to re-learn/learn as much math as possible. I've always wanted to be better at math. One thing I've always regretted is how much time I wasted in my high school AP Calculus class, only to have to take the same exact course my first semester in college. Combine that will all of the other math knowledge I've lost over the years and I feel like I should knkow much more than I do.

I'm starting from the very beginning, algebra, which should hopefully be more of a review than anything else. I ordered this book from Amazon the other day and plan to read a little bit each day while I eat breakfast. I haven't really determined what the end-state of this goal is. Maybe it will be a life-long thing and I will end up a math genius :)

It hasn't been necessary for me to know much high-level math in my development career. But I'm hoping that this project will enhance my problem solving skills and expand possible job opportunities. If nothing else, it will make me feel like I've made up for all of the knowledge I have lost over the years

Grader: Other GUI Thoughts

2008-03-13T19:14:00.000-07:00

I listened to a very interesting inteview on ITConversations.com the other week. The interviewee was Bill Buxton, a principal researcher with Microsoft Research and author of Sketching User Experiences (now on my Amazon wish-list).

In the interview, Bill talks about using sketching, at the simplest level possible, to allow creative though and to get away from preconceived notions about what software has to look like. A very interesting non-software example he provided was that George Lucas intertwined scenes of the chariot race from Ben-Hur with NASCAR wreck footage, to sketch out the pod-racing scene in the The Phantom Menace. This technique allowed him to sense how the scene would play out with little expense or time commitment.

This interview struck a chord with me because I didn't really brainstorm too much on what the Grader GUI would look like. The grading data is tabular so I immediately envisioned an entry table and implemented it that way, not really considering any other options. Maybe a wizard-like entry system would have made for a better user experience (not likely :) ). But I didn't even give myself the option of brainstorming and allowing some bad ideas help spurn some ideas that might have worked better.

I'm also currently reading Tog On Software. This book was written in 1996 and predicts a user-interface revolution happening ten years out. Since the book is twelve years old, it's interesting to see how much of the book's predictions have yet to become reality. One of Tog's predictions was that computer systems would have seamless voice recognition systems by now, which got me thinking about how well Grader could work with such a user interface. A user speaking the words "2", "1", "2" "0", "Next Player", "0", "Next Play", etc... would likely be much easier than typing the scores and using the tab/arrow keys to move between cells. I think I might look for some open source voice recognition software and see what I can do with it. That sounds like a fun project and would probably be a good thing to learn for the future.

Anyway, I think these two sources have made me think harder about user interface design and the process involved. I especially took to heart Bill Buxton's interview as "sketching" is a general purpose technique that can be applied to all areas of creative thinking, not just UI design.

Grader: GUI

2008-03-13T18:58:00.000-07:00

I find GUI programming to be enjoyable most of the time, with dashes of frustration thrown in for good measure. The fun part is the rapid feedback loop that exists as changes appear immediately on screen. It's also easy to bang out the code and get a lot accomplished in a short amount of time. The frustration comes in when my perfectionist tendencies inspire me to spend an inordinate amount of time trying to get every last detail exactly right, something that is quite difficult to do.

I've worked with QT for quite a while now (5+ years give or take) and really enjoy working with it. Having started out my professional career writing in Java, I like the similarities between the QT framework and the Java Standard library. But like the Java Standard library, QT is quite large and can require a lot of digging to uncover functionality you know is likely to exist, but doesn't seem to exist where you expect it.

Case in point...the Grader application uses a QTableWidget to allow users to enter player grades. After quickly getting the initial GUI up and running, I was surprised to see the cells of the table were not expanding to fit the entire widget, leaving empty white space along the bottom and right borders. I knew there had to be a way to correct this issue, but searched high and low through the QT documentation, unable to find it.

I reached the point where I was ready to give up, subclass QTableWidget, and write some overly complex code that filled the widget, making sure each column and row was the same size, handling resizing issues, etc... But one last search resulted in me finally finding what I needed in the QHeaderViewClass, the class that provides the table's row/column headers. I probably skipped over the function at least once when skimming the documentation, making things even more frustrating. But at least I didn't spend any time rewriting functionality that already existed.

I tackled two other issues in the first iteration of this project: fast data entry and displaying the grading data.

Fast Data Entry
I wanted to make sure the user could complete data entry without having his hands leave the keyboard. I used QActions to provide shortcut keys to save a play (Ctrl-S) and output a report (Ctrl-W). These actions exist in a menu, which I didn't really want to add as I didn't even want to give the user the option of using the mouse. But the QActions didn't seem to be active unless the menu was available.

Displaying Grade Data
My first attempt at this functionality was to display the entire grading table at the top of the window, using a QLabel with the text set to an html table. However, this resulted in a lot of screen clutter and looked really ugly. My next attempt was to just set the QLabel text to an html table that contained two columns, one for the grading scores and one for the grading descriptions based on the current selected column in the grade entry table. This worked well except that the table was always changing sizes and required the user to refocus when looking at the grade data. My brother actually complained about this problem when I gave him the first iteration to test out. I settled on using another QTableWidget which has the benefit of staying a fixed size, but has the disadvantage of looking as if it's editable even though I disabled any selection of the table cells (disabling the entire widget didn't look correct).

Overall, I think the GUI is decent enough for something that I wanted to keep as simple as possible. There probably are still some sizing issues that could be handled better but at this point, I think that's running into the Law of Diminishing Returns.

Grader: KISS (Keep It Simple Stupid)

2008-03-05T20:46:00.002-08:00

When my brother first asked me to write this program, he mentioned that someone had suggested to him he could solve his problem using Microsoft Access. I haven't used Access much before, but looked into it as a starting point. Creating the data tables was not a problem, but when I started looking at creating entry forms that spanned multiple tables, I decided it would probably just be easier for me to write an application from scratch.

At this point, I figured my next decision should be to decide which database to code against. I was picturing the ability to query on players, plays, years...quite a grand scheme. Taking a step back, I realized that my brother had asked for none of this functionality. All he wanted was a way to input grades for a single game and a summary report so he could evaluate each player's performance over the entire game. From this point on, I decided I was going to create the simplest program possible, focusing more on providing a solid user experience, and adding functionality only when it was requested. This decision resulted in the following decisions:

No Database
All of the data entered by the user is stored in memory and is lost once a game is completed (unless you count the report summary html file). This decision saved me quite a bit of time, and the more I thought about it, saving the data to such a history wouldn't provide much value at the high school level. Why would a coach care to save data for a player that is going to graduate in a year or two anyway?

At startup, the user must select two files that they previously created (or use the default files created by my brother), which contain the data needed for grading. The first file is just a text file that contains the list of players begin graded. The other file is a comma-delimited file that contains the grading scores, grading categories and descriptions of each score for each category. For example, a simple file might contain the following:

Score,Catch,Yards After Catch
1,Circus Catch,Ran for Touchdown
0,Catch,No Yards
-1,Drop,Lost Yardage

HTML Summary Reports
I was originally going to provide the summary reports in a dialog window once a game was completed. I was also intending to provide the capability to print that report. Having written some printing code before, I knew this would turn out to be complicated. I was pretty happy with myself when I thought of the idea just to generate an html report file. Not only could the user just print the file from his web-browser, but the html format allows the user to put reports out on a web server where other coaches can view the data.

The next two missing features are things I think I will eventually implement, even if my brother does not request them, as they would be generally useful.

No Backspace
At this point, the user cannot go back to a previous play after it has been submitted. This probably isn't a big deal as it shouldn't be too hard to enter the data error-free. But it might be nice to have that capability if a play is accidentally submitted before all the data has been entered.

All or Nothing
Grader currently doesn't support any concept of saving off partial results. So the user must enter a complete game at one sitting. I think it would be pretty useful to allow the user to enter complete game data over a series of application sessions. Of course, the usefulness would depend on how long it takes to enter an average game, information I will have to get from my brother. If it only takes 5-10 minutes, then maybe this isn't a worthwhile function to implement.

I saved myself a lot of time and was able to deliver the product much faster than if I had decided to move forward on implementing any of the above features. Instead, I was able to spend more time on solving the little problems faced when trying to make a GUI look just the way you want, which is the topic I will discuss in my next post.

Grader: What?/How?

2008-03-05T19:30:00.000-08:00

What?
Below is a screen-shot of the main window for the Grader application:

The Grading Key displays the grade data for the current grading category, which is determined by the current selected cell in the lower grade-entry table. The Grading Key provides a reference to the grading criteria as the user traverses through the grading table.

Although it does not require an entry, the play field allows the user to enter a name for the current play.

Other than that, the user simply enters grades for each player based on the grading criteria. As I said in my previous post, the application is pretty simple. The user submits the grades for a play by pressing Ctrl-S (or Grade->Save Play), at which point the grade-entry table is cleared and is ready for the next play.

At any point, the user can press Ctrl-W (or Grade->Write Game Report) to signal the completion of a game. At this point, the application outputs an html page that provides a grade summary for each player. Ctrl-N (or File->New Game) allows the user to start a new game.

The only other feature I provide at this point is the ability to pre-submit a list of plays when starting a new game. My brother's team already has a software package that tracks game information. This software allows them to export a list of plays which they can then just copy/paste into a dialog I provide. This results in a different "mode" in which the play field is disabled and is populated with the current play name as the user iterates through the plays. The Grader software then automatically generates the summary report after the last play has been submitted.

How?
I developed the program in C++, using the open-source version of QT (4.1) for the GUI. At some point, I want to put the application up on SourceForge so it is generally available.

The player data is stored in a designated text file and just contains the names of the players that will be graded. The grading data is stored in a designated csv file.

New Product: Grader

2008-03-02T19:23:00.000-08:00

I've recently released my first independent product. Calling it a product is a bit of a stretch as it is quite simple and isn't going to make me any money. However, it was a fun little project and I'd like to write a series of posts on some of the ideas/decisions I made while implementing it.

I created the application for my brother, who is an assistant football coach at the high school where he teaches. One of his responsibilities during the season is to review the film for each game, grading his players in several categories for each play. In the past, he completed this task manually, which obviously took quite a bit of time. Thus, he asked if I could develop an application that would help speed up this process and generate summary information to help him better evaluate his players' performance.

And so Grader was born (my creative juices were not flowing when I came up with the name). I think it turned out pretty well and will hopefully make his job easier. It also provides me with sample code to show any potential employers, although at this point it is probably too simple to make any kind of impression. However, I'm sure my brother will require more functionality in the future. I would also like to convert Grader to a web application using Ruby on Rails, as it would be an ideal project to dip my toes into learning that platform.

Is the Waterfall Method Just a Way to Procrastinate?

2007-12-29T19:58:00.000-08:00

This weekend, I finished reading the very good book The Now Habit: A Strategic Program for Overcoming Procrastination and Enjoying Guilt-Free Play, written by Neil Fiore. I really wish I had read this book before reading Getting Things Done: The Art of Stress-Free Productivity. The information in each book reinforces the other, but I think the information in The Now Habit would have provided a solid foundation to better understand the reasoning behind the strategies presented in GTD.

While reading The Now Habit, it was interesting to reflect on the information in the book as it related to the philosophies behind different software development methodologies, specifically Waterfall-like methods versus Agile-like methods. There were two main points of the book that stood out to me as related to software development.

Perfectionism
Fiore suggests that creative work requires workers to eliminate desires for perfection and allow themselves the opportunity to make mistakes. Perfectionism blocks workers from starting, making them afraid the initial steps they may be prepared to take aren't part of the "perfect" solution. Now compare the two different methodologies:

Waterfall Method: Requirements and design must be "perfect" before starting any development work. Mistakes in earlier phases must be avoided, otherwise their cost explodes in later cycles.
Agile Method: Development is undertaken with the understanding that initial ideas and design will need correction. Test-driven development provides a safety-net so mistakes cost less and can be corrected without fear of breaking other parts of the system. Working code is given preference to perfect code.

Frequent Rewards
Another suggestion Fiore makes is to plan work in short time intervals, giving yourself frequent rewards after completing discrete tasks needed to complete the project. Rewards that exist too far out into the future will only encourage a person to engage in activities that provide a more immediate reward (e.g. watching television). Comparing the methodologies once again:

Waterfall Method: At best, the development cycle is broken up into short iterations allowing for frequent feedback during that cycle. However, such feedback rewards will only occur after the Requirements/Design phases. Any rewarding feedback from customers on the working product can only occur when requirements changes are much more costly.
Agile Method: Short, frequent iterations reward the team with visible signs of progression. A short development iteration will have a proposed completion date near enough in the future to provide motivation to make the shorter deadline. The completion of each iteration builds momentum to move on and complete the next.

Should You Get A Master's Degree?

2007-12-10T20:21:00.000-08:00

I'm currently a couple of semesters away from (hopefully) earning a Master's degree in Software Engineering. It has been a long process, one that I'm anxious to see come to an end. Working full time, while taking one class per semester, drags the process out much too long.

If I could travel back in time, I'd tell my younger self two things:

Google's stock won't be overpriced at $100 when they have their IPO.
Don't waste your time getting a Master's degree.

Waste is probably too strong of a word as I don't feel the entire process has had no benefit. I was able to take two programming classes I didn't take as an undergraduate (databases, compilers), and I've learned quite a bit working on my thesis project (more on that later). Having a Master's degree may provide me the opportunity to teach later in my career, something I always thought I might enjoy.

But overall, I feel that my time spent on course/project work could have been spent on things that would have improved my personal brand much better. Looking back, I could have built a website using Ruby on Rails, contributed to an open-source project or spent more time improving my writing skills by blogging regularly (at this current moment, writing a blog post is a way to procrastinate on my project). All of these activities would make me much more attractive to a potential employer than would having a Master's degree listed on a resume.

My thesis project is an attempt to build an automated refactoring tool for C++ programs. I knew going into the project that writing such a program was a fool's errand. But it seemed interesting at the time and I knew the project would be approved. Although I have quite a bit of work left, assuming I get as much functionality completed as I think I can, I'll be pretty pleased with the end result. It will be more of a prototype than a complete program. But one only has to do a Google search on parsing C++ to see why I think a prototype would be a pretty nice accomplishment.

So to answer my question, no, you probably shouldn't get a Master's degree. Instead spend your time learning/building something you find interesting, something that could impress a future employer or turn into your own business.

If you ignore my advice and still want to get a Master's degree, I would then offer you this advice. Get your degree immediately after you finish your undergraduate degree. Don't start after you are in the work force and have to take more than two years to finish. Also, wait until after you earn your degree to get married and have kids. :)

Problem Solved

2007-10-08T19:43:00.000-07:00

In my last post, I talked about how include dependencies in our code base were causing lengthy build times. Well thanks to this entry on Jeff Atwood's blog, Coding Horror, our problem was solved overnight. Okay, our problem really isn't solved. We still have include dependency issues, but they no longer affect our build times, thanks to Incredibuild.

Jeff's mention of Incredibuild has completely transformed my day at work. A build that used to take over twenty-five minutes now takes about five minutes. I no longer have to worry about switching tasks/contexts to fill twenty-five minute voids throughout my day. I no longer have second thoughts about working in certain areas of the code, knowing that any small change would require a full rebuild. Refactoring can occur much faster and adds to the wave of motivation that has swept through our team since we began using this product.

Incredibuild is by far one of the best products I've ever worked with. Not only does it work as intended, but it was incredibly easy to setup. After reading Jeff's post, I downloaded the trial version and had the software working on two of my machines in less than fifteen minutes. A quick "You have to check this out..." email to my fellow team-members resulted in us having a seven machine build network by the end of the day. At that point, we started bugging management to approve purchasing the software and we are now on our way to becoming a much more productive team.

I am still trying to eliminate some of the worst include-dependencies/coupling in our code. But I no longer have to wait twenty-five minutes to get any feedback for my effort.

The Case of the Horrible Include Dependencies

2007-05-24T18:24:00.000-07:00

One of my favorite programming books is Working Effectively with Legacy Code written by Michael Feathers. The book provides an arsenal of techniques to refactor legacy code and get it into a test harness.

One specific situation the author addresses is testing a C++ class that has a large number of include dependencies. Our product has many classes that suffer from this problem. Our main library consists of over 600 source (.cpp) files and changes to a single header file often result in a large number of files having to be recompiled. A full rebuild takes over thirty minutes and is a productivity and motivation killer. I've decided to attack this problem at its root and try to eliminate as many of the dependencies as possible. At the very least, I will reduce the number of times a full-rebuild is necessary and will hopefully see a noticeable reduction in compilation time in the future.

I started off by writing three Ruby scripts to collect data about the include dependencies for our product. The first script traverses our source tree, inserting the following line into each header file after the header guard:

#pragma message("including __FILE__")

The second script parses the compilation output, tabulating the number of times each header file is included and how many header files each .cpp file includes.

The final script is the inverse of the first and removes all of the #pragma directives.

The scripts were easy to write and they output the exact information I want, so I don't think a code analyzer tool would have saved me much time. The main downside to my approach is that I have to do a full rebuild anytime I want to get all of the current data. But since this project is something I'm doing on the side, rapid feedback isn't that important. I can just kick off the build and come back to it when I have some down time.

Since beginning this project two weeks ago, I have been able to significantly reduce the include dependencies on about half a dozen header files. For example, one header file that was being included 455 times is now included only eighteen times. That is quite a time saver the next time someone changes that header file.

It's very motivating to see the include dependencies shrink after each small improvement I make. In his book, Michael Feathers talks about situations where programmers feel the code the work on is beyond repair. He points out that little changes here and there begin to add up, and you slowly realize the situation isn't as bad as it seems. I think the small victories I've had so far point to continued success and will result in a much better code base and a much more productive team.

Great Experience with Unit Testing

2007-04-22T08:52:00.000-07:00

This weekend I planned on stopping in at work for an hour or two to clean out some simple things on my TODO list. Unfortunately, upon opening my email, I was greeted with a message that our overnight build/run system had failed. In particular, a unit test suite for a library that I had created had failed to pass. The email also indicated that our application had significant changes in output from its previous run, something that wasn't expected for any changes that had been checked in the past day.

The unit test failure struck me as quite odd since the code in that library hadn't changed in over a year. I reran the test suite in my development environment, found the test that was failing and noticed that an output string I was expecting had changed. This failure gave me an immediate clue to where the problem was introduced, and with great satisfaction, I was able to track down the problem in no time.

As it turns out, my unit tests were not the only code expecting to see that same string value. Another major library in our system, which controls output functionality, had failed due to the changes that had been made. This library is much more complicated and does not yet have test coverage.

What I found significant about this experience, was that my unit tests had caught an error in functionality outside of the library they were testing. The library I wrote is pretty trivial, and I actually wrote the tests after writing the code (tut, tut) to try and introduce unit testing to my team. So an exercise that I felt was pretty academic at the time, had a significant practical payoff. Had I never written those tests, I would have spent much more time tracking down the change that had caused the problem.

Lesson learned: Unit tests not only test the primary functionality being tested. They can also test secondary functionality that the primary functionality depends on. Even if a test seems pointlessly trivial, its worth writing as it may uncover problems in other areas of the system.