Rental Car Preferred Clubs And Mobile Internet

Today, on my trip to Minnesota to speak at the user group, I found myself with an Avis reservation but no car.  There was a 1-hour wait for cars, even with a reservation.  Preferred members were, however, instructed to get their cars at the Preferred desk.  Cars were coming in at the same rate that new Preferred members arrived.  Therefore, it seems that we plebeians with mere reservations would have to wait a considerable time for a car.

I did wait about 2.5 minutes before pulling out my laptop, tethering my BlackJack II, and getting on the Internet through the AT&T Cellular network.  I browsed to Avis.com, signed up as a Preferred member and then promptly walked to the Preferred desk and chose one of the three cars waiting there.

I was then on my way.

MattN sent this great link:  Seinfeld loses his reservation:  http://www.youtube.com/watch?v=dSZYsyrP3Co

Visual Studio 2008 SP1 crashed on Vista x64

For the folks looking for an answer:

I had something happen today that normally doesn’t happen.  I loaded a solution, and Visual Studio just closed.  No error message, no dump.  It just stopped.  Gone.  I tried many, many times, and it crashes silently when opening one particular solution.  It works fine on every other solution.  At first, I thought I’d disable my add-ins, so I disabled:

  • ReSharper
  • Gallio
  • TestDriven.Net

I even reinstalled PowerCommands because I found someone who had a problem with that.  Nothing worked.  I finally started thinking about the variables.

The one variable I missed was that this solution had last been worked with before I upgraded to Visual Studio 2008 SP1.

Solution:  I deleted the *.suo and *.cache files next to my solution file.  I reopened the solution, and everything is fine.

Software Management Workshop – call for interest

We (Headspring) are starting to offer half-day workshops on various topics where we have expertise.  One of the new workshops that has had tremendous registration is the Afternoon of ASP.NET MVC.  The next workshop topic that I’m currently planning is a Software Management Workshop

This workshop would be most appropriate for software managers and leaders.  Every organization is different, but through the years, I, and my colleagues, have acquire quite a bit of knowledge surrounding the management of software projects and software organizations.  The plan is to start giving some of that knowledge back to the community through free half-day workshops in Austin, TX.  We might consider videoing if there is enough interest.

If you have opinions and/or ideas for extra topics, please comment below.  This type of workshop would not involve any programming.  It is intended to be all about software management and team management.

JetBrains RubyMine provides navigation and refactoring for Javascript

Working with JQuery in Visual Studio, we don’t have all the nice navigation, refactoring, and immediate error visibility we have with C# and ReSharper.  Today I installed RubyMine, a brand new IDE from JetBrains.  I opened up a javascript file and was pleased to find that the ReSharper/IntelliJ IDEA experience transfers over one-to-one.  All the shortcut keys are the same and all the refactoring and navigation was here, too.  It makes working with Javascript a breeze!  This IDE is brand-new, and I hope that they will plop this functionality into ReSharper for Visual Studio users, but for now, this is a good workaround when dealing with some non-trivial Javascript.  In this screen-shot below, you can see that I pressed CTRL+SHIFT+F7 to show usages of “this._jqm”.  It highlights all the usages, just like with ReSharper

I then tested out the refactoring and extracted a variable with CTRL+ALT+V.  The following dialog was to be expected, and it refactored just like I’m used to with C#.

       

This is a very interesting IDE, and I’ll be keeping tabs on it.  It is focused for Ruby development, but it can be useful apart from a server-side framework.

New Agile Boot Camp Dates (March 11-13)

We have new dates for the Agile Boot Camp part 1 and part 2.  If you are interested in raising your agile team’s development to the next level, give us a call. 

You can sign up online or over the phone (or with a purchase order). 

Below is some of the information about just the part 1 class.  And yes, we cover all of it in 3 days.  That’s why it’s called a Boot Camp.  If these dates don’t work for you, there are more.

 

 

Part I Agile Boot Camp™ Topics:

  • object oriented programming
  • SOLID principles
  • design patterns
  • dependency injection
  • team design on whiteboard
  • IDE tools and quickly navigating a codebase
  • test driven development
  • mocking
  • pair programming
  • refactoring
  • pain driven development
  • domain driven design
  • ORM
  • contributing to open source projects
  • harnessing the community for extreme growth and continuous learning
  • foundations of Agile

What will I need to do to prepare for the training?

You’ve learned the .NET Framework – now learn the principles and tools to use it effectively. This intermediate curriculum will lead developers to work-changing techniques and create momentum towards continuous improvement in an ever-changing field. With a focus on object orientation and software engineering practices refined in real projects, students will discover principles and patterns to manage software complexity. By the end of the course students will have eliminated a reliance on leaky-abstraction APIs by

  • understanding software design concepts and principles
  • understanding and practicing test-driven development
  • practicing working in an effective team
  • implementing designs using object oriented techniques and design patterns
  • understanding object-relational mapping
  • drive future growth through exposure to advanced topics

Day 1

getting started

  • lab 1: check out the project and run a unit test
  • module: Intro
  • module: TDD basics
  • lab 2: writing your first failing unit test
  • lab 3: writing the code that makes it pass
  • demo: working with resharper

LUNCH

object oriented programming

  • module: SOLID
  • lab 4: interfaces, facade
  • lab 5a: strategy pattern
  • lab 5b: command pattern
  • extra curricular lab: playing with structuremap

Day 2

team design & advanced tdd

  • quick mini-lab involving structuremap
  • module: dependency injection / ioc
  • lab6: configuring structuremap
  • demo: testing with mock objects
  • lab7: rhino mocks
  • team design on whiteboard

LUNCH

refactoring & pair programming

  • lab8: more tests, enumeration base class, specification pattern, .NET 3.5 feature in the code
  • module: refactoring
  • demo: refactoring legacy code
  • lab 9: pair tasks involving refactoring
  • extra curricular: student-driven discussion and demo

Day 3

morning session

  • lab 10: “refactor this” challenge
  • module: DDD basics, terminology
  • lab 11: repositories, using provided nhibernate stuff (HSB, DTB, etc.), specification pattern
  • module: foundations of Agile

LUNCH

conclusion

  • module: nhibernate
  • demo: querying nhibernate
  • lab 12: downloading source, creating patch for open source project
  • student-driven discussion, demos

Gmail Offline Works Well

This week I enabled Gmail Offline.  You have to install Gears, which not seems like Google’s answer to Flash, Java, Silverlight, and the other mini-runtimes that need to leverage the client computer.

When I have a slow (or no) connection, I can flip Gmail into “Flaky Connection Mode”, and I can search my inbox, read, write, and send mail.  When I have a connection again, Gmail syncs up just like normal.  Very interesting feature.  I wonder when I’ll have to start paying for Gmail.  I’d be happy to.

In Defense of Uncle Bob and the SOLID Principles

Since blogs and podcasts are so searchable these days, I have no doubt that many novice programmers will find the material discounting the SOLID  principles and the work of one of the founders of the Agile movement.

Context:  Original published audio programFirst response by Robert MartinAttempt at clarification by Jeff AtwoodFurther backing of SOLID principles by Robert Martin.

By the blog comments on each of these, there are people with strong opinions on both sides.  I don’t think it is as black and white as taking sides.

For what it is worth, I, and my company, have found the SOLID principles very beneficial for the quality of the software systems we build.  By applying them weighted against experience, systems are easy to maintain and extend. 

Lack of experience might cause someone to attempt to apply them in a dogmatic, bureacratic manner.  This would fail just as surely as any attempt made by an inexperienced programmer; however, the appropriate application of these principles is a boon to a codebase.  I have found that my more senior programmers are able to apply the principles through experience, and those who are still learning the principles can see the concrete applications of them and duplicate them. 

The results are very clear and very positive.  For instance, on our current, largest project, the codebase continues to be easy to maintain and extend weekly.  Even complex business logic is easy to break down, test and verify.  New logic can be layered on (extended) without causing lots of churn with existing code (OCP).  The application of the SRP causes our code files to be small enough to understand quickly, and interface and method names are very specific, describing the responsibility.

I am not on a crusade to change the entire industry.  That takes time, and customers still don’t value success enough to ask the tough questions before hiring programmers.  Until the marketplace demands higher quality work, programmers around the world will continue getting paid for shoddy software.

Organizing Software Projects

Brendan Enrich has an interesting post on organizing the trunk of the source control for a system.  Some of the principles include:

  • Having all libraries with the source code
  • Having a batch file for the build right at the top
  • Sitting down and working immediately with the project.

I like what I see.   I think this type of structure should be widely used across many types of .Net solutions.