.NET people make everything so difficult

I do lots and lots of development with the .NET platform, mainly because the corporations in the Cleveland area that have money to fund large projects are Microsoft shops.

I used to have a real problem with Microsoft development, back when it was all Windows 95; the tools were expensive, flaky, and unreliable. Since then, the tools have improved to an amazing degree; now I can write code that actually works consistently on more than one computer, and it’s not utterly ridiculous to run Windows on servers anymore. So there’s that.

But in just the last couple of days, I’ve gotten back into the Ruby on Rails environment. Partly, I’m jamming with my college homie Dave Stagner on his amazing Congruence product; and also, I had to update this old Perl script that I’ve been using for years to sort my incoming email.

Continue reading “.NET people make everything so difficult”

Cost of convergence

You can’t afford to: create the installer, finish the release notes, and tie up all those little loose ends. Not for every increment. It takes a long time and the effort simply isn’t worth it.

I was recently developing a significant new feature on an ASP.NET application. The client’s regular dev team is located in India, but for this new feature they wanted somebody whom they could work with face-to-face, and having me dedicated to the project (for a short time) seemed like an advantage.

We started off really well. I was able to get into TFS for version control, connect to the development database, and add a few basic pages to get started.

Continue reading “Cost of convergence”

At the Old Programmer's Club

Another late night at the Old Programmers’ Club. This time, Tony and The Smartest Guy I Know talk about how Microsoft ruined the static keyword.

Last night I regaled The Smartest Guy I Know, as well as drsweetie’s high school pal Tony, with tales of how Kids These Days Don’t Know Anything and Nobody Does Things Right. It was a scene to warm the bitter soul of any software curmudgeon.

“So there I was,” I began, “optimizing the heck out of an ASP.NET application…” And my audience groaned–although I’m still not sure whether it was because they know how the story simply had to end, or because I was the teller and they couldn’t be sure that it would ever end. Because my stories get to be like that sometimes.

Continue reading “At the Old Programmer's Club”

Lessons Learned

Lessons learned from the last big on-site web development project: figure out what the client really needs, gauge the effort, know who the chump is, and lunch strategically.

Yesterday, I finished up my part of a web development project, working with a team put together by a local software consulting company. Here are a few things I learned or had reinforced:

Figure out what the client really needs

A lot of times I pick up a project that’s a real mess, and the client thinks they need a supercoder to get it all done. I don’t think of myself as a supercoder, and even if I were such a person, the lack of one is usually not the problem. More often, when a software project isn’t going well it’s for reasons like these:

  • redoing the same work
  • poor choice of platform
  • unclear goals
  • not enough time allocated
  • multiple agendas
  • poor controls
  • hoarding
  • wrong kind of discipline
  • reliance on heroics
  • technical “bankruptcy” (when the code gets too complex to maintain)

What do these things have in common? They aren’t solved by supercoders.

You know what though? As I found it, this project had acquired good management and it had a very clear goal. Some of the specific requirements could have been better defined, but there was enough wiggle room that we weren’t really hampered by any vagueness. And our team lead, someone I’d happily worked with in the past, was very capable.

I could have applied some of my amazingly insightful make-your-project-not-suck magic, but no: what this project needed was a supercoder, or two or three. So I did the best I could in that regard.

I’m not talking about the “duct-tape programmer” type that Joel Spolsky lauds in his recent blog post. This website already had enough duct tape! It just would have been extra-awesome if I’d been able to understand the whole code base in a flash, and figure out how all the duct tape worked, rather than having to piece my mental model together one defect at a time.

Gauge the effort

In business terms, a key element for any independent consultant or small contracting firm is knowing how many technical people need to be on the project, and for how long. Nobody wants to be so overbooked they fail to deliver on commitments. Nobody wants unanticipated slack time.

At first, they told me it was a one-month “burst” kind of project. Then, based on burn rate, they scaled it back to three weeks. A bit later the client found more funding to make it five weeks. Then another burn-rate-related adjustment reduced my role to four weeks.

Does that sound awful? Maybe? It’s not. When it’s one of those park-yourself-in-a-cube-and-join-in endeavors, you rarely get that level of communication and adjustment. A lot of clients make it really hard to plan ahead. This one kept adjusting and communicating their time expectations, without being overwhelming about it. Cool.

Know who the chump is

They tell me it’s a truism in poker: There’s one chump at every table; you want to figure out who the chump is. Corollary: if you can’t identify the chump, it’s you.

The blunt truth is that in team software projects there is very often at least one person who hasn’t the skills to contribute much. That’s not always a bad thing: it can be a great opportunity for mentoring via pair programming, code reviews, or simply talking about how code gets done.

I really liked and respected the .NET developers I worked with on this project. On the downside, I couldn’t figure out who the chump was. I made my best effort, but I suspected that my process of understanding the existing code base was just taking too long. At the end, I realized that it took a month to figure out where everything was in this modestly complex system, which is about normal. Still, I hate that feeling: “Am I the chump? Really?”

Lunch strategically

One of the cool things about working at the client’s site is that it puts you in a geographic location that you can leverage. One of my Twitter pals works right upstairs from our war room. Another good friend works afternoons and evenings in the same office park. Our quality lead was a vague acquiantance from a project I did last year when he worked for a different organization.

So I got to optimize my lunch and snack time. I found out about new jobs opening up, in unrelated areas, for which other friends might qualify. I was able to refer my Twitter pal to two industry peers she didn’t already know. I got to hang out with, and get the latest relationship drama from, my office-park neighbor.

Those things wouldn’t have happened had I stayed in my home office or remained virtually connected via coffeehouse WiFi. It was a lot more driving than I like to do, and my car actually suffered, but at least there was that social benefit.

I’m just saying

It was a good engagement. The client is doing a lot better now than before we started, and their confidence will improve even more when the remainder of the team gets cracking on load testing and optimization. Congratulations all around!

Just wanted to share this code gem

You never need to compare to true.

I spotted this in some ASP.NET today:

if (confirm("Are you sure?")==true)
return true;
return false;

You never need to compare something to true though:

if (confirm("Are you sure?"))
return true;
return false;

And the whole if-boolean-then-boolean construct can be refactored out:

return confirm("Are you sure?")

It’s less to maintain, less to look at, and simpler to understand. That is all.