BigJimInDC

The Application of Pareto's Principle to the Adoption of Agile Practices - Part 1 of N

2010-03-19T10:45:00.001-04:00

Starting this evening, I will be attending the Agile Coach Camp in Durham, NC. As the only registration fee for attending the ACC is to submit a position paper on a topic of interest to you, I submitted the following abstract.

The Application of Pareto's Principle to the Adoption of Agile Practices
If you believe in Pareto's Principle (otherwise known as the 80-20 Rule), then you believe that it can be applied literally everywhere. At its heart, Agile practices are about doing what works and ignoring the rest (at least until the time is right). In a world where people are constantly searching for silver bullets, getting distracted by zealot turf wars, and feeling the crunch of deadlines, novice adopters of Agile practices need to learn what out of"agile" is immediately important for their situation, and what they can safely ignore until a latter point in time.

So I figure why not put some more concrete thoughts together before the ACC starts. This post is the first of probably a couple posts on this topic, with probably at least one being a follow-up if my topic gets accepted as a discussion topic. Seeing how I average roughly 5 hits/month on this blog, it wouldn't hurt to get a little more traffic!

I also want to emphasize one important point to avoid having to defend a position that I'm not taking. This opinion of mine revolves around the adoption of agile practices. It in no way is an attempt to water down agile, as every individual practice discussed below certainly adds value and should be part of the full vision for any team attempting to go agile. This opinion simply revolves around the idea of getting the most bang for your buck up front so that you can get all of the nay-sayers on board the agile train sooner than later.

Review of the 80-20 Rule
The 80-20 Rule is typically explained as for any given "effort", the first 80% of the results you are looking for will be accomplished with only 20% of your time and energy, while the final 20% of the results will take 80% of your time and energy. When applying this to the adoption of agile practices in software development efforts, the gist is that only 20% of the ideas/topics will get you 80% of what you were looking for when you decided to start using agile practices.

Review of Agile topics
For the sake of discussion, I'm going to use part of James Shore's table of contents from his book The Art of Agile Development. The following is Part II - Practicing XP from his ToC, as these are the concrete practices that his book discusses:

5. Thinking (1. Pair Programming, 2. Energized Work, 3. Informative Workspace, 4. Root-Cause Analysis, 5. Retrospectives

6. Collaborating (1. Trust, 2. Sit Together, 3. Real Customer Involvement, 4. Ubiquitous Language, 5. Stand-Up Meetings, 6. Coding Standards, 7. Iteration Demo, 8. Reporting)

7. Releasing (1. "Done Done", 2. No Bugs, 3. Version Control, 4. Ten-Minute Build, 5. Continuous Integration, 6. Collective Code Ownership, 7. Documentation)

8. Planning (1. Vision, 2. Release Planning, 3. The Planning Game, 4. Risk Management, 5. Iteration Planning, 6. Slack, 7. Stories, 8. Estimating)

9. Developing (1. Incremental Requirements, 2. Customer Tests, 3. Test-Driven Development, 4. Refactoring, 5. Simple Design, 6. Incremental Design and Architecture, 7. Spike Solutions, 8. Performance Optimization, 9. Exploratory Testing)

The above chunk of his ToC represents a total of 37 practices across 5 concepts areas. As this opinion paper is not about paraphrasing James Shore's book, I will not make any attempt to describe any of the above practices any more than is necessary to make my points. If you are unfamiliar with any of the valuable practices that he describes, buy and read the book.

My 20% - Take 1
Seeing how James broke out the 37 practices into 5 concept areas, that makes it easy for me to make my first arbitrary application of the 80-20 Rule and grab Chapter 7 (Releasing) from above as the one concept area that you will get the biggest bang for your buck on. As software developers we get paid to produce working software. I've seen many a team over the past 15 years get caught up when releasing new versions of their software. Some developers spent days to weeks just trying to get the code to compile. Others had to "wing it" during the deployment of the code to a test server (the consummate "it worked on my machine" excuse). If you can't look at your current situation and proudly say we have the whole release process down pat and can consistently get new releases out with minimal effort, then start with this chapter.

My 20% - Take 2
Given the first application of the 80-20 Rule above to the 5 concept areas, this second application of the rule is going to be across the 37 practices (20% of 37 = 7.4 practices). My list of the 8 practices out of James Shore's 37 practices are:

#1 - Thinking - Root-Cause Analysis

James Shore's 99 words description:

When mistakes occur, blame your process, not people. Root-cause analysis helps. What allowed the mistake to happen? What will prevent them in the future? Assume people will continue to make mistakes and build fault-tolerance into your improvements.

One approach: ask "why" five times. Use it for every problem you encounter, from the trivial to the significant. You can apply some solutions yourself. Some will require team discussion, and others need coordination with the larger organization.

When mistakes become rare, avoid over-applying root-cause analysis. Balance the risk of error against the cost of more process overhead.

My take on it:

This practice is actually a twist on the 80-20 Rule in that it focuses you in on the issue that actually does need to be worked on rather than the issue that you either think needs to be worked on or worse case, the issue that you simply would like to work on.

#2 - Collaborating - Trust

James Shore's 99 words description:

For maximum productivity, team members must rely on each other for help. They must take joint responsibility for their work. Trust is essential. To improve trust, foster empathy. Learn about your teammates' joys and concerns. Sitting together helps, as does eating together. Preserve productive teams by keeping them together for multiple projects.

Organizational trust is also essential. Be energetic, deliver on your commitments, and be honest about problems. Show that you care about your stakeholders' goals. Promote your work through friendly openness. Always be honest about your achievements. Avoid the temptation to whitewash problems or misrepresent partially-done work.

My take on it:

In life as a whole a lack of trust leads to a constant downward spiral of every relationship. In agile, we are talking about teams, including both developers and customers, and therefore we are talking about relationships. Without trust, the process is going to fail.

#3 - Collaborating - Real Customer Involvement

James Shore's 99 words description:

To widen your perspective, involve real customers. The best approach depends on your market.

Personal development: you are the real customer. Congratulations. Go forth and write algorithms.

In-house custom development: turn your real customers into on-site customers.

Outsourced custom development: get real customers to be on-site customers. If you can't, stay in touch and meet face-to-face frequently.

Vertical-market and horizontal-market software: beware of giving one customer too much control. Appoint a product manager to understand customer needs. Create opportunities to solicit feedback. Examples: customer review board, beta releases, and user experience testing.

My take on it:

In my corner of the world, teams of "consultants" attack projects with little to no subject matter expertise but armed with years of experience in producing working software. This demands that customers are involved throughout the process, as only the customers have the subject matter expertise necessary for the project's success.

#4 - Releasing - "Done Done"

James Shore's 99 words description:

A story is only complete when on-site customers can use it as they intended. In addition to coding and testing, completed stories are designed, refactored, and integrated. The build script builds, installs, and migrates data for the story. Bugs have been identified and fixed (or formally accepted), and customers have reviewed the story and agree it's complete.

To achieve this result, make progress on everything each day. Use test-driven development to combine testing, coding, and design. Keep the build up to date and integrate continuously. Demonstrate progress to your customers and incorporate their feedback as you go.

My take on it:

Seeing how I called out Releasing as the single most important concept area, I'm going to go forward and proclaim that this particular practice is the single most important practice of all. Teams must be able to demonstrate progress daily and the sub-practices of test driven development and continuous integration are fundamental to enabling that.

#5 - Planning - Vision

James Shore's 99 words description:

Every project needs a single vision, and the product manager must unify, communicate, and promote that vision.

Distance between visionaries and the product manager increases error and waste. If you only have one visionary, the best approach is for him to be product manager. Alternatively, use the visionary's protogé.

Some projects have multiple visionaries. They need to combine their ideas into a unified vision. The product manager facilitates discussion and consensus.

Document the vision with what success is, why it's important, and how you know you've achieved it. Post it prominently and involve your visionaries in planning and demos.

My take on it:

Without a vision, a team can never confidently answer the question "is this topic important?" And without being able to answer that question, teams can get caught up in building software that they think is needed, without being able to justify it. That ultimately leads to lost productivity when they incorrectly answer that question.

#6 - Planning - Release Planning

James Shore's 99 words description:

Maximize your return on investment by:

1. working on one project at a time;
2. releasing early and often;
3. adapting your plans;
4. keeping your options open; and
5. planning at the last responsible moment.

Use timeboxing to control your schedule. Set the release date, then manage scope to meet that date. This forces important prioritization decisions and makes the endpoint clear.

Prioritized Minimum Marketable Features (MMFs) and stories form the body of your plan. Demonstrate your progress as you develop and use that feedback to revise your plan.

To minimize rework, develop the details of your requirements at the last responsible moment.

My take on it:

Some adopters of agile think that agile is all about "no documentation and no planning". They couldn't be more wrong, and thus why I'm including this practice. As James Shore points out, agile planning is about planning and adapting to changes.

This is in contrast to project managers of the past who created a project plan in MS Project at the beginning of the project and God help you if you as a developer created a situation where that project manager had to open MS Project after the project started to adjust the plan based on new information.

While I don't believe that there is anything particularly wrong with using MS Project, when using it in an agile environment the project manager maintaining the plan must update it weekly. If they don't do this, then they need to either throw out agile or throw out MS Project.

#7 - Developing - Test Driven Development (TDD)

James Shore's short description:

We produce well-designed, well-tested, and well-factored code in small, verifiable steps.

My take on it:

From a code construction point of view, if your team is not already using TDD, adopting TDD will raise the level of quality of the software that your teams are delivering. Simple as that.

#8 - Developing - Incremental Requirements

James Shore short description:

We define requirements in parallel with other work via living requirements documents and working incrementally.

My take on it:

Even in the best of the waterfall projects of days gone by that I worked on (and apparently even on the ones that I didn't), the up front requirements phase never produced a complete set of requirements. The agile practice of incremental requirements simply accepts that as a fact and creates a solution framework for continually dealing with it as the norm, rather than treating it as scope creep and denouncing it as something unexpected and bad.

Closing Thoughts
Hopefully this sparks some level of discussion for this weekend's Agile Coach Camp. If not oh well...

Apple iPad and Text Books

2010-01-27T16:30:00.002-05:00

I'm probably not going to be the first one to mention this, but I want to go on record as early as possible that the single "killer app" for the newly released iPad is college text books.

I've been an iPhone 3GS owner since the day it was released and have loved every second of it. That is in stark contrast to the prior years of owning Palm and Windows Mobile phones, of which to say were terrible is in understatement. I've also been a huge iPod supporter for years now too, having recently bought my third one.

That said, I personally don't see any use for the new iPad. I currently use my iPhone for email and web surfing, and could see where using an iPad would be nicer, given its bigger screen. But I would never take the iPad anywhere other than the living room couch with me, as the form factor is simply too big (compared to the iPhone which nicely fits in my pants or jacket pocket). And since I can type on a regular keyboard at over 60 words per minute, I don't think that the iPad and its 10" screen is going to replace my regular desktop/laptop with its 24" screen anytime soon either.

But back to the college text book thing... if Apple were to be able to pull off selling college text books (and K-12 text books too) for use on this thing at say 25-50% the normal price of hard copy text books, the iPad would pay for itself in one or two semesters. And students get to stop carrying around the back breaking backpacks filled with the text books that they currently have too. And that's not even taking into account the added technological aspects of having ebooks that you can mark up as you please. Now THAT would lead to Apple selling millions upon millions of these things. Maybe that current stock price of $208 is low after all...

Review of NDepend

2010-01-08T12:50:00.001-05:00

DISCLAIMER

Patrick Smacchia, the creator of NDepend, offered me a free license for NDepend Pro if I took the time to review the product and write this review on my blog. While I have not used NDepend prior to doing this review, given the fact that I have been reading Patrick's blog for quite some time now, along with the fact that I'm a big fan of static code analysis (for the regular identification of problematic areas in your source code), I happily agreed to his offer.

THE REVIEW

Installation
The installation of NDepend is a simple unzip and xcopy to your desired location. Seriously as simple as it gets. Once it's there, fire up the VisualNDepend executable and point it at some .NET/C# assemblies you have.

Analysis
I decided to run NDepend against a code base that had been handed down to me from a number of prior developers. While the customer is happy and the application has been running in a production environment for a couple of years now, the application is also a serious legacy code development situation, and a great sample project to see what NDepend has to offer for people in my shoes.

So after loading up the half dozen assemblies in the given application, NDepend made quick work of analyzing everything and producing a nice HTML report. It also shows the results in the Visual NDepend results browser, allowing you to quickly navigate around your code base.

Usage Scenarios
After immediately showing a peer of mine the tool what it does, I started rattling off to him the following list of scenarios that describe how I think NDepend can be useful to developers.

#1 - Newbie - Never used NDepend before and barely understands static analysis or any of the metrics used by NDepend.

In this scenario, much like in my code base above, NDepend will quickly point out problematic areas of your source code so that you can immediately start addressing those issues.

Now I'm sure that plenty of readers will immediately start screaming that the metrics aren't useful.

In response, I say that when you're reviewing a code base, and the documentation says that a Cyclomatic Complexity rating above 15 means that a method is complex, and above 30 is nearly impossible to comprehend, that if you're staring at a list of 20 methods with a rating above 30, including 5 with a rating above 40 and 1 with a rating above 80, you can't for a second argue with me that the tool isn't immediately useful in helping focus you in on the sections of your code base that you REALLY might want to stop and clean up. In other words, this is all about quickly focusing you in on the sections of your code base that just aren't good, no matter what your opinion is on the specific threshold for a particular metric.

#2 - Novice/Intermediate - You're familiar with the tool and the concepts and your code base is generally ok per the tool.

In this case, you're looking at integrating NDepend into your (hopefully pre-existing) continuous integration environment so as to ensure constant feedback to yourself and/or your team regarding the "health" of your code base. The value here is that NDepend comes with pre-existing plug-ins for NAnt, MSBuild, and CruiseControl.NET which means you can very quickly get NDepend integrated into your automated process.

#3 - Expert - You're already highly automated and compliant, but feel the itch for more.

In this case, NDepend really shines given the existence of CQL, it's own built in query language, that allows you to run queries against the metrics that it collected during the analysis phase. All of the functionality that #1 and #2 are leveraging is simply based on a set of pre-built CQL queries. But for the expert who is obsessed with perfection, automating their perfection seeking is even better. And being able to either tweak the pre-built queries, or better yet, build a series of custom queries is priceless.

Gripes
It wouldn't be right to review something and not offer some advice. That is what I get paid for in my real job! Anyway, one big thing that jumped out at me that was annoying was that I quickly found myself lost in the UI. I think that this is due to the specific UI controls and the docking layout stuff that is used by NDepend to try and organize the eleven navigation and results windows. I actually got things so messed up that thankfully NDepend has a "Reset Views" menu item that puts things back to how they were when I first launched it. I also found that once I got the set of windows that I found useful (for scenario #1 above) in view and the rest hidden, things were much smoother.

I think that to help resolve this in general, it would be nice to have a set of additional pre-built views, as there are a couple of task specific ones that already exist, that fit more in line with the three usage scenarios above.

I'd list price as an issue here too, but more from the point of view that I think Microsoft should simply pay Patrick a chunk of change and integrate NDepend into Visual Studio. Now that we've finally got people on board with automated unit testing (hopefully you're already doing this), now's the time for fully automating and enforcing code quality metrics! Unfortunately, unless a developer already knows about and has respect for static analysis, they probably aren't going to hunt down and pay a couple hundred dollars for a tool like NDepend. And then you have teams such as the one I'm currently on that simply doesn't have the budget for ANY tools, so we aren't going to use it either.

Summary
So in the end, NDepend simply rocks! While I had issues with the UI, that's something that after 5-10 minutes of use you don't really even notice. The immediate impact that NDepend can have on a code base is priceless. Just think, all of those code reviews everyone says they should be doing but never have the time to do can now be automated, and team members are simply responsible for maintaining the code quality ratings of the code they write.

Thanks to Patrick for giving me the chance to review what turned out to be a great tool. Using NDepend coupled with ReSharper and FxCop, code bases simply have no excuse to end up in the mess that so many of them are today.

Developing Temporal/Time-Based Database Solutions

2009-09-18T17:13:00.003-04:00

Since I've already gotten a couple of requests for this information, I guess it's time for another blog post.

The following is based on my research on the subject, after having developed a temporal/append-only solution a couple of years ago (before knowing what it was called by academics). Considering that Professor Richard Snodgrass of the University of Arizona is THE person that I've come across that has written the most on the subject, you should check out his list of publications on the subject here first:

http://www.cs.arizona.edu/people/rts/publications.html

The key one from what I've read so far is "Developing Time-Oriented Database Applications in SQL". Most, including this one, are available as electronic downloads.

I've also noticed that Joe Celko (http://www.celko.com/books.htm) has written on the topic in his book titled "Joe Celko's Thinking In Sets - Auxiliary, Temporal, and Virtual Tables in SQL".

Now that I've apparently gotten some people's attention on this subject, perhaps it's time for me to start a series of blog posts on the subject...

Temporal Database Design, Soft Deletes, and Ayende's Razor

2009-08-31T16:52:00.003-04:00

This is a formal follow-up to a post on Ayende's blog on "Avoiding Soft Delete's" in your database where I question the lack of temporal database solutions being applied to these types of problems.

After Oren claimed the following, I felt it necessary to expand on it in a blog post of my own, rather than continuing to clutter his comments, and hopefully finally bring some traffic to my own blog :-)

Ayende’s Razor

This is a response to a comment on another post:

Oren, in all seriousness, I thought that problems that were "(a) complex, (b) hard to understand (c) hard to optimize" were the kinds that folks like you and I get paid to solve...

Given two solutions the match the requirements of the problem, the simpler one is the better.

I could just as well call that statement "Jim's Razor", as I believe in it as much as you do Oren, so no arguments there.

But in the same vane, "wise" (i.e., experienced) software architects/developers strategically chose RDBMS's over flat text files for the same class of reasons that I believe we should be making temporal database concerns first-class citizens of the modern IT toolbox. The "additional features/functionality" gained by employing temporal databases, while never stated up front in requirements, would be priceless in the long run for business systems. Those features include, but are not limited to:

automatic audit logging, since nothing is ever UPDATE'd or DELETE'd, you've got a constant trail of changes
automatic support for infinite undo/roll-back support of data, as you simply load a prior version and then save as usual
automatic support for labeling of versions, much like in source/version control systems, at an individual record level, table level, "aggregate root level", or database level
automatic support for "back querying" a system, in search of what the situation looked like last month, last year, etc. (though raising this "aspect", as in AOP, to the ORM level would be crucial)

IMHO, switch/case statements are generally simpler than polymorphism (demonstrated by how switch/case statements are typically taught before polymorphism in academic settings), but we all know why polymorphism in the long run is the better strategy, and therefore why as soon as we see switch/case statements propagating their way into our code bases, we typically change to a polymorphic strategy.

Again, the goal in my eyes is to raise temporal database concepts to the level of first class citizens in the IT world, as opposed to the back water, academic debates that they are today. The major players like Microsoft with SQL Server have never bothered to implement the temporal extensions to ANSI-94 (yes, from 1994 - see this). Interestingly enough Oracle has implemented some of them via Oracle 9i and 10g, but per the work of Snodgrass and friends, still have room to perfect things.

This is also where the "minor players", i.e., the open source software community via projects such as NHibernate could step in and heavily promote something like this. In the same line of thinking of not wanting to constantly roll your own ORM, thus why you chose something such as NHibernate, needing to roll your own temporal solution for every project should be equally unnecessary.

In closing, for all of the "pain" of implementing something as complex as this topic would be, I'd love to see a platform such as Microsoft Dynamics (MS CRM) implement this all the way from the database through to the GUI, as it would clearly represent a paradigm shift in business information systems development. Of course perhaps I should just start a company to do just this...

MS SQL Server Named Instances and Aliases For Heterogeneous Developer Environments

2009-08-03T11:11:00.003-04:00

On the team that I'm working with, we're supporting MS SQL Server 2000, 2005, and 2008. Depending on when the particular developer joined the team, and thus when they installed the various pieces of software on their development workstation, any of the above listed versions might be the default instance (i.e., "(local)"), while the others might be installed as named instances (i.e., "(local)\SQL2008" or "(local)\SQL2K5").

Every once in a while, a developer has to work on a project with a database installed to a local database server that is on a named instance other than the rest of the development team. With the database server name stored in .config files, altering this for each developer just doesn't make much sense. Thankfully, MS SQL Server has a very simple and straightforward solution for this - aliases.

By using aliases, an application under development can be configured to use an alias in the .config file, and each developer simply needs to create a alias on their workstation pointing to their particular named instance.

Anyway, you can either decipher what MSFT KB Article 265808 has to say, or just follow the step-by-step instructions here (for MS SQL Server 2005):

#1 - Open SQL Server Configuration Manager

#2 - Confirm that TCP/IP is enabled for the named instance for which you are creating the alias.

#3 - Confirm that "Listen All" is set to "Yes" for TCP/IP for that instance.

#4 - Take note of the port number listed next to the "TCP Dynamic Ports" setting under the "IPAll" section.

#5 - Right-click the "Aliases" node and select "New Alias..."

#6 - Fill in the details for the new alias.

Alias Name - I like the idea of choosing a name for the alias that a) isn't already a name on the network (obviously) and b) is named for the application that we are developing. It is irrelevant that you have 2, 5, 10, or 500 aliases all pointing to the same database server (web hosting services have done this for years when hosting hundreds of websites on a single server).
Port No. - This is the value from "TCP Dynamic Ports" in step #4 above.
Protocol - Confirm TCP/IP is selected.
Server - This is the database server name you would "normally" use to connect to the particular database server. Note that the SQL Server "(local)" alias works as part of this solution, and in conjunction with or without a named instance name, is what should go in this box.

NOTE #1 - Aliases are "local" to the specific workstation they are created on. In other words, every developer on the team will need to create the alias on their individual computer.

NOTE #2 - Yes, the dev team could standardize the way software is installed on their computers. But on my team, we get paid to do what our client wants us to do, and not to arbitrarily streamline" and tweak every last detail of our development environment. Besides, using aliases just works, and unless someone can comment on why this is technically a bad idea, I'm not going to ever condone wasting my client's money.

Hotmail.com and Live.com email access to your iPhone

2009-06-29T20:40:00.003-04:00

So being the proud new owner of an iPhone 3GS after years of dealing with the inferior Windows Mobile and Palm platforms, I'm also learning the ins and outs of "things that should be easy".

Take for instance the fact that MSFT only offers crippled POP3 access to Hotmail/Live.com, thus making those nearly worthless on the iPhone. Thankfully the fine folks at FluentFactory make just the thing to make Hotmail/Live.com mail on the iPhone nearly what it should be (for those of us with a many, many year history with our Hotmail accounts).

http://fluentfactory.com/mboxmail/

But that said, looking at what Google has to offer for synching to the iPhone, I can't help myself from laughing!

http://www.google.com/mobile/apple/sync.html

The following paragraph copied from that page is the key:

Important! Google Sync uses the Microsoft© Exchange ActiveSync© protocol. When setting up a new Exchange ActiveSync account on your iPhone, all existing Contacts and Calendar events will be removed from your phone. Please make sure to back up any important data before you set up Google Sync.

Pretty sweet when Google licenses ActiveSync from MSFT for connecting GMail for use on the iPhone, while MSFT refuses to offer the same functionality for Hotmail/LiveMail users, even the paid ones like me! WTF MSFT?!?!?!

Touch Typing - i.e., eaking seconds and minutes out of your day

2008-10-28T15:34:00.002-04:00

After being forwarded a link to Stevey's Blog Rants: Programming's Dirtiest Little Secret today, I figured I'd do a blog post on this topic too. IMHO, if you sit in front of a computer all day long, especially as a computer programmer, and can't touch type faster than 60wpm, start practicing for 30 minutes a day with one of these tools until you can.

http://www.keybr.com/ (This is the one that I like the best, but a few more follow.)

http://typera.tk/

http://play.typeracer.com/

http://www.touch-typing-tutor.com/

http://www.typingweb.com/

Incorrectly Storing Objects In The ASP.NET Session

2008-09-30T15:45:00.005-04:00

In an effort to keep this from happening to someone else, I figured I'd write about it today. I'm surely not the first person to ever write about this, so I'm not claiming to have found something novel. I've personally never written a web application that needed to utilize the ASP.NET Session object, but apparently other folks have not learned that.

Anyway, the following chunk of code was being used to store a reference to the "domain object" currently being viewed/edited.

namespace Your.Web
{
 /// <summary>
 /// Summary description for ContainerBase.
 /// </summary>
 public class ContainerBase : Page
 {
     public virtual IDomainObject DomainObject
     {
         get
         {
             if (Session["DomainObject"] != null)
             {
                 return (IDomainObject) Session["DomainObject"];
             }
             else
             {
                 return null;
             }
         }
         set { Session["DomainObject"] = value; }
     }
 }
}

The result of doing this is that by opening one "domain object" (DO1) for editing in a window (W1), hitting CTRL-N to open a new window (W2) that by default will still show DO1, navigating to a new domain object (DO2) in W2, then switching back to W1 and clicking the Save button without any other operations, the edits in W1 that should be being applied to DO1 are actually being applied to DO2. Dooh!!!! That eliminates a user's ability to have two or more web browser windows open at a time. MS-DOS, here we come!

Moral of the story, don't use the Session object, unless you really truly have read everything there is about using it and are still convinced that you should still use it. And even then, you're probably still wrong!

For further reading, see the ASP.NET Session State Overview on MSDN.

The Overuse of the StringBuilder class in .NET

2008-09-26T11:29:00.005-04:00

So this friend of mine Adam wrote this post today. The main point of the post I love, as it correctly abstracts the creation of the query string behind a class and away from the rest of the code that is consuming the query results. Why I'm writing this post is that while his post was not directly having to do with the StringBuilder class, IMHO, he is displaying what I believe is indicative of the over zealous use of the StringBuilder class.

For the sake of convenience, this is how he wrote it:

private static string BuildDefaultViewQuery()
{
 var builder = new StringBuilder();
 builder.Append("<Where>");
 builder.Append("<Eq><FieldRef Name='DefaultView' /><Value Type='Boolean'>");
 builder.Append("1");
 builder.Append("</Value></Eq></Where>");
 return builder.ToString();
}

This is how I would have written the guts of this method:

private static string BuildDefaultViewQuery()
{
 return String.Format(@"
         <Where>
             <Eq>
                 <FieldRef Name='DefaultView' />
                 <Value Type='Boolean'>{1}</Value>
             </Eq>
         </Where>",
     1);
}

I just happen to think that there is too much "noise" when using a StringBuilder for this kind of stuff. Yes, if you're looping through a potentially large set of data and producing a potentially large string as a result, then by all means, use a StringBuilder, as that is what you should be doing. But if you're just building a relatively static string, with a handful of "variables" inserted into the string, use String.Format() in conjunction with a string that supports line breaks (i.e., using the @"" syntax). The resulting code is so much easier to read and understand what is really going on besides the building of a string.

SharePoint/MOSS 2007 External Third Party Desktop Application Integration

2008-09-24T15:09:00.004-04:00

Today I was presented a scenario where a client wanted to integrate a non-Microsoft Office desktop application into their Microsoft Office SharePoint Server 2007 (MOSS) environment such that documents created/edited in that app and stored in MOSS document libraries were able to be directly opened into that app ready for editing, and ultimately saved back to the document library.

Since Google'ing the answer to this scenario took me more than 30 seconds to find, here is the answer.

Inside SharePoint - Integrating "Office" Applications
http://technet.microsoft.com/en-us/magazine/cc565180.aspx

And here are some more useful links:

Text Files, Associations, and SharePoint
http://weblogs.asp.net/bsimser/archive/2005/01/24/359911.aspx

Sharepoint Beef #3 : Melt-in-your-mouth Native Apps support issue resolved
http://weblogs.asp.net/dburke/archive/2004/01/13/58330.aspx

SharePoint.OpenDocuments Control
http://msdn.microsoft.com/en-us/library/ms454230.aspx

How to enable the “Edit in Microsoft Office XXXXX” feature for Office 2007 documents
http://www.syntergy.com/sharepoint/products/tips/

DocIcon.xml - Adding Notepad and WordPerfect as applications
http://www.sharepointblogs.com/korry/archive/2006/03/16/docicon-xml-adding-notepad-and-wordperfect-as-applications.aspx

Adding a Document Template, File Type, and Editing Application to a Site Definition
http://msdn.microsoft.com/en-us/library/ms868275.aspx

PDF Integration in SharePoint
http://www.specialinvestigations.org/blog/CommentView,guid,1a6f8f2b-55a1-4421-bf11-b1256ea418dc.aspx
http://www.portalsolutions.net/Blog/Lists/Posts/Post.aspx?ID=40

Customizing the Shortcut Menu for List Items
http://msdn.microsoft.com/en-us/library/ms868274.aspx

Customizing SharePoint Context Menus
http://blogs.msdn.com/bowerm/articles/175691.aspx

HDD and Thumb Drive Performance Comparison

2007-12-13T14:45:00.000-05:00

So, since I tend to be a speed freak of sorts, I wanted to see just how well, or not, my storage devices perform. In my Dell Precision M90 laptop, I've got a Seagate - Momentus 100GB drive, then a Western Digital Passport 250GB USB external drive, and finally a PNY Attaché 16GB USB thumb drive.

The following are the screen shots from HD Tune that indicate how each performed:

All in all, I'm fairly pleased. My primary desire is to simply have capacity. But when you start storing GB sized database files and virtual machines, better performance can mean a lot!

Automatic Updating of AssemblyFileVersion in C# Projects

2007-10-23T18:00:00.000-04:00

So my good buddy and co-worker Stacy Draper and I put together a solution today to handle versioning of .NET assemblies used for SharePoint web part development. Maybe this has been done before, maybe even better than this, but a quick Google search didn't turn up squat for us, or at least anything we liked, so we created our own solution.

The general problem revolves around the fact that the AssemblyVersion attribute in .NET assemblies is used by other assemblies when referencing strong named/signed assemblies stored in the GAC. Now you don't have to put your SharePoint assemblies in the GAC, but in most all cases, it simply makes the most sense. If you change the AssemblyVersion of an already installed and used over and over and over again web part, you're in a world of hurt if you arbitrarily change the AssemblyVersion to something new. At that point, you're faced with having to update 10's to 100's to 1000's of web part pages that reference the original web part. That's not to say there aren't times when it makes sense to do so, but for day to day development and deployment scenarios where it really isn't a new version of the web part, but itis an updated version of the code, you still want to be able to have a very noticeable way to see what version is currently installed on your portal.

So that takes us to what Stacy and I whipped up today. I created a script that updates your AssemblyInfo.cs file, setting the AssemblyFileVersion attribute to a time-stamped version number, based off of the AssemblyVersion attribute's value, of when the assembly was built. Stacy created a script that updates the feature.xml file that is part of the SharePoint feature with the new version number of the AssemblyFileVersion to be displayed within the description of the feature. This is so you can also see that version info from within SharPoint, in addition to viewing the file properties. Both of these scripts are then configured to run in your pre-build events for your C# project. What follows is my pre-build commands and the content of my VBS script. I place my VBS file in a folder named UTIL inside my C# project. See Stacy's blog for his stuff.

CD "$(ProjectDir)UTIL"
cscript /nologo UpdateAssemblyFileVersion.vbs "$(ProjectDir)Properties\AssemblyInfo.cs"

'------------------------------------------------------------------------------
'--- UpdateAssemblyFileVersion.vbs
'------------------------------------------------------------------------------
'--- Author - Jim Sally
'--- Date   - 2007.10.23
'------------------------------------------------------------------------------
'--- This updates the AssemblyFileVersion attribute in the AssemblyInfo.cs file
'--- of a given C# project.  The AssemblyFileVersion is updated to contain the
'--- first two digits of the AssemblyVersion, with YMMDD.HHmm as the last two
'--- digits.
'------------------------------------------------------------------------------
Option Explicit

Dim fileHeader
fileHeader = "UpdateAssemblyFileVersion.vbs :: "

EnsureCommandLineArgumentExists
EnsureAssemblyInfoFileExists WScript.Arguments(0)
UpdateAssemblyFileVersion WScript.Arguments(0)

Private Sub EnsureCommandLineArgumentExists()
    If WScript.Arguments.Count <> 1 Then
       WScript.Echo fileHeader & "You must supply the path to the AssemblyInfo.cs file as the only argument on the command line"
       WScript.Quit 1
    End If
End Sub

Private Sub EnsureAssemblyInfoFileExists(AssemblyInfoFileName)
    Dim fso

    Set fso = CreateObject("Scripting.FileSystemObject")
    If Not fso.FileExists(AssemblyInfoFileName) Then
       WScript.Echo fileHeader & "AssemblyInfo.cs does not exist at the path provided -> " & AssemblyInfoFileName
       WScript.Quit 1
    End If

    Set fso = Nothing
End Sub

Private Sub UpdateAssemblyFileVersion(AssemblyInfoFileName)
    Dim assemblyInfo, newAssemblyInfo

    assemblyInfo = GetContentsOfAssemblyInfoFile(AssemblyInfoFileName)
    newAssemblyInfo = UpdateAssemblyInfoText(assemblyInfo)

    If newAssemblyInfo <> assemblyInfo Then
       SaveContentsOfAssemblyInfoFile AssemblyInfoFileName, newAssemblyInfo
    End If
End Sub

Private Function GetContentsOfAssemblyInfoFile(AssemblyInfoFileName)
    Dim fso, file

    Set fso = CreateObject("Scripting.FileSystemObject")
    Set file = fso.OpenTextFile(AssemblyInfoFileName)
    GetContentsOfAssemblyInfoFile = file.ReadAll()
    file.Close

    Set file = Nothing
    Set fso = Nothing
End Function

Private Sub SaveContentsOfAssemblyInfoFile(AssemblyInfoFileName, infoText)
    Dim fso, file

    Set fso = CreateObject("Scripting.FileSystemObject")
    Set file = fso.CreateTextFile(AssemblyInfoFileName, true)
    file.Write(infoText)
    file.Close

    Set file = Nothing
    Set fso = Nothing
End Sub

Private Function UpdateAssemblyInfoText(AssemblyInfoText)
    Dim posAV, posAFV, posEolAV, posEolAFV, aNAV
    Dim originalAssemblyVersionText, originalAssemblyFileVersionText, newAssemblyFileVersionText

    posAV = InStr(AssemblyInfoText, "AssemblyVersion")
    posAFV = InStr(AssemblyInfoText, "AssemblyFileVersion")

    If Not IsNull(posAV) And Not IsNull(posAFV) And posAV > 0 And posAFV > 0 Then
       posEolAV = InStr(posAV, AssemblyInfoText, "]")
       posEolAFV = InStr(posAFV, AssemblyInfoText, "]")

       originalAssemblyVersionText = Mid(AssemblyInfoText, posAV, posEolAV - posAV)
       originalAssemblyFileVersionText = Mid(AssemblyInfoText, posAFV, posEolAFV - posAFV)

       aNAV = Split(Split(originalAssemblyVersionText, """")(1), ".")
       newAssemblyFileVersionText = "AssemblyFileVersion(""" & GetNewFileVersionNumber(aNAV) & """)"

       If originalAssemblyFileVersionText <> newAssemblyFileVersionText Then
           UpdateAssemblyInfoText = Replace(AssemblyInfoText, originalAssemblyFileVersionText, newAssemblyFileVersionText)

           WScript.Echo fileHeader & "Updated attribute from '" & originalAssemblyFileVersionText & "' to '" & newAssemblyFileVersionText & "'"
           WScript.Echo
       Else
           WScript.Echo fileHeader & "AssemblyFileVersion attribute already '" & newAssemblyFileVersionText & "'"
           WScript.Echo
           WScript.Quit
       End If
    Else
       WScript.Echo fileHeader & "AssemblyVersion or AssemblyFileVersion attribute not found"
       WScript.Echo
       WScript.Quit 1
    End If
End Function

Private Function GetNewFileVersionNumber(versionArray)
    GetNewFileVersionNumber = versionArray(0) & "." & versionArray(1) & "." & GetVersionYMMDD() & "." & GetVersionHHmm()
End Function

Private Function GetVersionYMMDD()
    Dim y, m, d

    y = right(year(now()),1)
    If y = 0 Then
       y = 10
    ElseIf y > 6 Then
       m = (y - 6) * 12
       y = 6
    End If

    m = Right("00" & (m + Month(now)), 2)
    d = Right("00" & Day(now), 2)

    GetVersionYMMDD = y & m & d
End Function

Private Function GetVersionHHmm()
    GetVersionHHmm = Right("00" & Hour(Now()), 2) & Right("00" & Minute(Now()), 2)
End Function

Missing MOSS 2007 Functionality

2007-10-05T12:01:00.000-04:00

So having been using MOSS 2007 for the past 3 months now, I figured I'd put my own stake in the ground as to some things that would be quite handy to be built into the product. Yes, there are probably ways to do some custom webparts to handle some of these, but IMHO, these are pieces of functionality that should be part of the base product. Hopefully they make it into the next version...

List View Security

This follows some of the same logic behind the use of a database VIEW. An administrator should be able to create a SharePoint list view with a row-level filter and then secure the list of views to the appropriate folks (to the point of hiding views a user doesn't have access to use).
This would allow various business scenarios to be simply handled via view security. For instance

hiding items based on the state/status code of an item to augment workflows
storing heterogeneous content types, but securing which are visible to whom

List Item Column Security

This is very similar to the view security above, but at a column-level, rather than row-level (vertical security versus horizontal security). In fact, this could work very similarly to how views currently work, but could be called item views, instead of list views.
Yes, you could write custom ASPX pages to handle this, but the point of this functionality is to give a non-developer the ability to create this kind of functionality.

Custom Attributes On Lists

This is more or less a property bag (key/value pair bucket) that can be populated via the GUI by an end user, or via the API.
This would be primarily useful to a developer who wants to track/manipulate additional details about a list, but enable end-users to make changes to those values when necessary.

Programmatically Accessing Excel Data via .NET on 64-bit servers

2007-08-30T17:16:00.000-04:00

So it turns out that using ADO.NET to access MS Excel worksheet data in an ASP.NET application running on the 64-bit version of Windows Server 2003 does not quite work as expected. This also goes for any 64-bit .NET code. In short, the Microsoft.Jet.OLEDB.4.0 provider is a 32-bit driver that does not work when directly used by 64-bit code. The following post from a Microsoft employee describes the issue:

Connect to Excel. Using x64 (64-bit) platform. Compiled as x64

"Since there are no 64-bit OleDb drivers for anything other than SQL Server, therefore, we cannot write 64-bit apps which interface with databases directly.

What you need to do is split your application into a 32 bit part and a 64 bit part, use COM interop to cross the 64/32 bit boundary. For instance, drop the code (just a simple class library compiled as 32 bit) that retrieves the Excel data into a COM+ (System.EnterpriseServices) as a "server type" application, and call those server methods from your 64 bit Windows service. This is exactly why System.EnterpriseServices are made for."

To restate the above in a list of to do items:

Refactor the Excel access code into a class by itself in a class library by itself
Make sure that this new class inherits from System.EnterpriseServices.ServicedComponent so that it can be hosted within COM+ (Component Services)
Make sure the new ServicedComponent's class library is compiled in 32-bit mode
Alter the calling code (ASP.NET web page, control, web part, etc.) to call the new ServicedComponent for the Excel data retrieval routines
Install the new ServicedComponent into Component Services

Using Log4Net in 4 Simple Steps

2007-08-30T14:41:00.001-04:00

First off, yes, this is a complete rip-off from this blog post, but with value added in that this represents my personal preference when using log4net. This is a simple four step process of adding logging to an application. I prefer log4net over the MS logging application block, primarily as log4net has zero dependencies and NHibernate already references it. IMHO, if you're doing ANY kind of logging, reference log4net into your project and use it instead of Trace.WriteLine() or Debug.WriteLine().

Step 1. Add the following in the AssemblyInfo.cs

[assembly: log4net.Config.XmlConfiguratorAttribute(
                         ConfigFile = "log4net.xml", Watch = true)]

Step 2. Create the log4net.xml file and add the following to the new file

With respect to the location of this file and SharePoint, this file can exist in the root of the wss root, next to the relevant web.config file for the given site. In general, this should sit next to the app.config or web.config file for the given application.

<log4net>
<appender name="GeneralLog" type="log4net.Appender.RollingFileAppender">
 <file value="${TEMP}\\Logs\\AppName_${COMPUTERNAME} " />
 <appendToFile value="true" />
 <rollingStyle value="Composite" />
 <staticLogFileName value="false" />
 <datePattern value=".yyyyMMdd.'log'" />
 <maxSizeRollBackups value="10" />
 <maximumFileSize value="5MB" />
 <lockingModel type="log4net.Appender.FileAppender+MinimalLock" />
 <layout type="log4net.Layout.PatternLayout">
     <conversionPattern value="%d{HH:mm:ss.fff} [%t] %-5p %c - %m%n" />
 </layout>
</appender>
<appender name="DebugAppender" type="log4net.Appender.DebugAppender">
 <layout type="log4net.Layout.PatternLayout">
     <conversionPattern value="%d [%t] %-5level %logger - %message%newline" />
 </layout>
</appender>
<root>
 <level value="ALL" />
 <appender-ref ref="GeneralLog" />
 <appender-ref ref="DebugAppender" />
</root>
<!-- Print only messages of level ERROR or above in the package NHibernate -->
<logger name="NHibernate" additivity="true">
 <level value="ERROR" />
</logger>
</log4net>

Step 3. Add the following at the top of your class

private static readonly log4net.ILog log = log4net.LogManager.GetLogger(
                System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

Step 4. Add the following line in the code where you want logging to be done

log.Info("Program Started " + DateTime.Now.ToString ());

References

Apache log4net Home Page - http://logging.apache.org/log4net/

Potential solutions to the prior mentioned hack about KB928365 and ASP.NET Request Header modification

2007-07-28T13:28:00.000-04:00

As "Anonymous" asked about my referenced solutions to the hack to resolve issues with MS KB928365, I figured instead of simply writing a follow-up comment, I would simply create a follow-up post. That said, I can imagine at least two primary solutions to this, each depending on your exact situation.

First off, with regards to my situation, I can create a provider pattern solution for looking up the enterprise provided AUTHID, such that if I want to fake it, my code isn't directly coupled to a value out of the header, but simply an interface that provides an AUTHID. I would then create two separate implementations of the interface. The first implementation would be the DEV simulation implementation, which would read the AUTHID out of the XML configuration file that we are currently using to inject into the request headers (for use in DEV). The second interface implementation would be one that reads the value off of the request headers (for use in PROD). You then configure which one is in use via your web.config, or via your Dependency Injection (DI) or Inversion of Control (IoC) framework (i.e., StructureMap, Windsor, Spring.NET).

Second, if you don't have that level of control of the situation, you are probably stuck with having to create a custom reverse proxy server to sit in front of your application that injects the AUTHID before making the request directly to your application.

Overall, the first solution is an order of magnitude more desirable. It is very much the "proper" object oriented approach, as it creates a loosely coupled solution that can be easily reconfigured, and more importantly, tested. And I would also highly recommend against even considering deploying the second solution in a production environment. It should only be used for simulating things for development purposes.

Blogs vs. Articles

2007-07-13T20:51:00.000-04:00

I love this post! It's posts like this one that I swear Ayende Rahien and Jeremy Miller are my long lost brothers. Week after week, those two get down in writing what I've been thinking about for quite some time, but until recently, didn't even bother to have a blog to write in myself.

Overall, Nielsen is simply incorrect, much as O'Brien points out. Roughly 10 years ago, as a new college grad, I spent some time in the publishing world as a Technical Editor on a number of articles and two books. I did it, because I thought wow, there could be my name in print. But just doing those few jobs, not even being the author, I quickly came to realize all of the same things Larry points out in his post, so I stopped pursuing the publishing world any further.

Since then, second to a few choice books most folks are aware of, blogs have become the primary source of learning on my end. The amount of posts that I queue up daily in Google Reader as Starred Posts and then read while commuting to work, in elevators, at lunch, in waiting rooms, in conference rooms, etc on my WM5 Smartphone makes keeping up with this stuff seamless. Toting around magazines, print-outs, and/or books just isn't practical these days.

MS KB928365, ASP.NET Request.Headers.Add() Hack No Longer Works

2007-07-13T12:40:00.000-04:00

So a project that I am currently a part of is using an ASP.NET 2.0 HttpModule to add some additional values to the incoming HTTP request's headers in the DEV environment (i.e., our local disconnected laptops) to simulate what an enterprise single-sign-on solution is performing in the production environment. It has worked like a charm. That is until I installed the new security update for the .NET Framework 2.0 release this past Wednesday, July 10, MS KB928365.

Apparently this "hack" has been disabled with the release of this security update.

When attempting to call Headers.Add(), with or without the above hack in place, you will now receive a PlatformNotSupported exception.

All in all, this post is by no means a rant against the security update, but simply an attempt to add a quick answer to the "Google answer machine" for those searching. I am also already aware of a number of other potentially better solutions than the one currently in place for simulating those user accounts, but for now, simply uninstalling the above referenced security update gets the team back working again.

Using Multiple iPods on a Single Windows Computer

2007-06-12T17:00:00.000-04:00

So I got a new laptop a week ago, and in the process was determined to figure out a better way to sync both my girlfriend Anne's 4GB iPod Nano and my 60GB iPod Photo using the single laptop.

With the last laptop, I created an additional user account to be used just for managing the iTunes library for my iPod. Anytime I needed to sync my iPod, I logged off my "primary" user account and then back in with a "secondary" user account used just for managing my iTunes library. I was convinced that there had to be a better way, but simply hadn't spent the time trying to find it. With the new laptop in hand, I was determined to find out what the answer was.

After Google'n for an answer, I found a number of solutions similar to the following ones:

http://lifehacker.com/software/itunes/multiple-libraries-in-itunes-7-202302.php

http://www.allthingsmarked.com/2006/09/13/howto-manage-multiple-libraries-in-itunes-7/

http://www.mcelhearn.com/article.php?story=20050124101441405

But none of them struck me as what I wanted the solution to be.

I then remembered the RUNAS functionality built into Windows XP, which in short, allows you to execute any given program under a different security context (i.e., using a different user account than the one you are currently logged in with). I then gathered that I should be able to run an instance of iTunes using RUNAS via a secondary user account.

So I created the secondary user account that I would use for managing my iTunes library, logged in with the secondary user account, and launched iTunes to ensure everything was working as expected. I then imported my iTunes library from the old laptop, etc. I then logged back in with my primary user account for the laptop and used RUNAS to launch iTunes with the secondary user account.

In short, it worked perfectly! The only hick-up of sorts was trying to figure out how to get the "Run as..." option to show up on the context menu for the iTunes icon on my Windows Desktop. The trick is to hold down the shift key while right-clicking the icon.

It was bound to eventually happen...

2007-06-12T16:30:00.000-04:00

...that I would start a blog.

Anyway, I've spent better than the past 5 years now reading other people's blogs, and steering clear of starting my own. I still don't think I have the time to offer a lot of content, but hopefully what I do post will be more useful than this obligatory intro. The only real reason I decided to start this was to give myself somewhere to post write-ups on random topics that I couldn't find an answer to via Google. Hopefully posting those write-ups here will save someone else some time some day.

In the mean time, you can keep yourself busy reading my Google Reader Shared Posts.