10-Second Usability

I’ve always know there had to be some rule or logic that someone has laid out for usability.  Especially from a marketing perspective.  Recently I took to reading a few pages of Web Analytics Demystified by Eric T. Peterson.  While reading through the book in the very first few pages the 10-second usability rule is mentioned.  It reads:

  • One tenth of a second (0.1) is the limit for a user to feel that a system is responding immediately when engaged in a task.
  • One second (1) is the limit for a user’s flow to remain uninterrupted, allowing them to notice a delay but not losing the feeling of direct connection with the task.
  • Ten seconds (10) is the upper limit for keeping users focused on a single task.  When faced with delays of ten seconds or longer, users have a tendency to engage in side tasks or become frustrated with the lack of system response.

Thinking back over the last few years I’ve known more than a few people that needed a lesson in this concept.  Simply put, if you aren’t aware or paying attention to this concept when building UIs, you are already VERY close to failing.

So keep it close and in mind, a second is too much to lose!

Oh Freaking Sweetness! November Release Date!

So Microsoft has promised a November release date for .NET 3.5 and VS 08.  I’m stoked that it will (could?) be out by end of month!  The funny thing is I found out by reading about a SQL Server blog entry.  In that entry Denis Gobo is wondering, which I do also, where is SQL Server 2008?  Eh, I’m still stoked, and don’t mind waiting, but it would be nice to have some news from that front also.

Cheers to 08′!

Unit Testing and Decisions on BAD Data

I was having a conversation with a friend about their particular predicament and how they got fussed at for taking time, after being directed to, to write unit tests for someone else’s code.  Not only had this individual been directed to do these tests, but after providing estimates based on the idea that the application already was complete, or at least in a testing state.  So with the idea that the application was more complete than it was, unit test writing initiated only to find that the application needed major fixes.

Now correct me if I am wrong, but unit testing is done to find these issues and errors.  Sometimes, most of the time, almost all of time, unit testing is going to take longer than writing the application straight.  But the application will be more solid, have better integrity, the ability for regressions, faster future development, less crashing, better organization, and assuredly better meet the requirements the application is designed to meet.  So when someone takes the time to assure this level of integrity, the last thing a manager or anyone should do is to not realize what is going on when unit tests are being created.  Writing a unit test, especially under a TDD process, is NOT JUST WRITING CODE!

Rant Number 345,251,090,253.

So, to all the managers in the world, please read and focus on what a unit test is.  The reason and purpose of a unit test is vital to getting the results of what is promised from unit testing.

So don’t ask your developers to go and unit test applications that they did not write unless you expect them to go through and literally verify every single “unit” of work that is being performed.  They have to write a “unit test” for each “unit” of work so they must understand each “unit”.  That means, for all practical purposes, learning the entire use case and application in detail.  Remember, if done properly, this will probably take almost as much time as actually writing the application did.  It’ll be worth it, but make sure to have good expectations of what kind of resources and effort this will take!

Writing unit tests after the fact like this is not a good way to go about coding, but sometimes it needs to be done.  It is definitely good to do test driven development instead of the post test development style.

So please stop expecting the market this mythical hype, get rid of the pointy hair boss syndrome, and start dealing with reality.

Learned, Relearned, and Learned Again, Agile Like

I have to admit, it is pleasant to “relearn” something versus trying to learn it the first time.  The images, explanations, and past learning pour back into my memory.  The memories and experiences are almost always good, the times fun, and the excitement of figuring out something the first time is renewed.

With that I’ve dived back into my most recent study of business intelligence and various OLAP technologies from MDX to the storage mechanism full force.  Lately I’ve reviewed again the storage mechanisms, working to figure out what is inside the “black box”, that makes the OLAP Cube.  Much of it I’ve recollected over the last few weeks with ease, but the black box is a bit of a mystery.

What got me thinking about this wasn’t the action of relearning these last few weeks, but an article I read that has to do with this exact topic.  The Secret Sauce of Highly Productive Software Development hits the nail on the head of what makes an Agile team truly effective and faster, sometimes exponentially faster than a traditional team of software developers.  Learning is a key to making a team fast.  The team must always learn, every day, every hour something different comes up and they must adapt.  Everything from the new pattern to implement a needed feature to the simple “I gotta hit this button even though it is not in the documentation” knowledge.

After all that being said, if there was one feature of Agile Methodology that I have to pull out of the bag of tricks and say is important, it is learning and adapting to the tools and the project.  This aspect of the methodology is more important than almost any other part, of course all the other parts are built around enabling the developers to learn, adapt, and have process that can handle and integrate the “learning” into the actual development process as much as possible.

All this thinking on the topic of Agile and the basic inferiority of previous methods lends more credence to why Agile itself is permeating almost every methodology these days.  It is strange, almost like the other methodologies, are attempting to “learn” Agile.  There are of course those people out there that are naysayers of Agile, and that is fine, they’ll probably be out of the software development sector of the industry within the next 1-5 years.  If not they’ll be relegated to the “maintenance role” of 35 years and will hopefully be happy with their “white picket fence” dream home.  I personally am ready for the challenge of staying well ahead of the curve, far away from the mediocrity of the average, and pushing the envelope as much as possible.  Addictions aren’t generally a good thing, but I am addicted to solving this learning bottleneck within project efforts.  Not only am I addicted, I’m intrinsically connected to the whole learning concept.

On that note, I’m back to the blogs, books, and personal efforts of the day.

Pond's Laws of System Design (A.K.A. Something to Ponder)

In my eternal effort to keep up with everything, or at least the things related to what I do…  I found an excellent law of system design list by Mr Ward Pond over on his blog.  I always find lists interesting, as statistics show almost everyone does, but these types are actually of use.  Many of the points are true to the occupation and definitely worth reading and acknowledging.  Some of my own thoughts around Mr. Pond’s Laws are generally reinforcing the general undertone of each law.  The ones I generally have 2 cents to add are following.

#5 Pond mentions that the “value you add goes triple for the value that the job brings to you”.  I absolutely agree.  I would also add the correlation that without value being brought to the individual doing the job it is a worthless job.  If you can’t enjoy, even in some small way, you should probably either find a way to enjoy somehow or get the hell out of that type of work.  When #5 goes the other way, not only do you not add value to what you do and your coworkers efforts, but you detract extensively from your own life.

#6 “Play” with the product.  If you aren’t, are you even really doing your job?  Something I commonly ask of advanced DBAs, Software Developers, and even Architects that don’t write code anymore.  What are you doing then?  Why are you not doing it?  Get back to it, if you aren’t playing, something is big time wrong!

#8 Please, I implore people to know this, to simply know thy self.  Without this, you will never be good at the whole aspect of human contact, which regardless of what some might think, is pivotal to doing a good job at anything!

…and that leads me to the last law that I really must reiterate…

#10 Your code is a communication with someone else, who will likely come after you are gone.  This is true, it is frustrating, and sometimes agonizing, but simple leave some kind of whimsical comment is better than nothing.  I’ve made gross errors in this area of my career, but ongoing I always try to improve my comments.  On the same note, but the other end of the view, make sure you learn to grasp and read comments and code.  Make sure you actually know the technology (see #6), don’t blame inadequate knowledge and ability on the “guy that left” because you don’t understand patterns, objects, the language, the technology stack, or other scope.  Always learn, keep learning, and don’t stop.  With enough knowledge, even the most cryptic spaghetti isn’t all that bad to fix.