CodeCuriosity

Conditions and Dictionaries

2011-10-17T20:29:00.000-06:00

Last week I was involved in some new employee code reviews and pairing interviews. Since most people that apply to ThoughtWorks do our Mars Rover problem, I decided that I should probably give the problem a try. The solution is pretty simple, which is probably why most people select this problem. I happened to be in a programming mood at the time, so I decided to make the problem a little more difficult.

Could I write a solution without an IF statement?

It turns out that I can and the results were very interesting. Here is the first cut of my spin left method before the change over.

Here is another deviation with if statements, because you know... switches are smelly.

Then here is what I came up with when trying to remove all my conditions.

Personally, I find it much more readable than the other two. This is something I would not have expected given an arbitrary challenge. Maybe those anti-if people are onto something.

Tackling Business Complexity

2011-10-01T09:16:00.000-06:00

This week at a client site, one of our stories came back from the dead because some condition wasn't handled. As we were implementing the story, our understanding increased and along with understanding came new questions. After asking these new questions, it became clear that there was a lack of holistic understanding for the both the developers and the business. The developers wanted a rationalized set of conditions, the business wanted things to be displayed in different ways when certain conditions were met. Basically, we wanted the same thing, but could not meet on a common language.

The thing we could agree on was what parts were important, so I came up with the idea of producing a truth table to hash out the different combinations. It looked a lot like the image below.

After creating the table, it was a matter of going through each combination and recording what expected result should be displayed. This produced five potential outcomes that turned out to be relatively simple to handle.

Looks almost too easy right? I'll assure you that the vernacular of the story did not cover the problem in such logical terms. The distillation of these guard statements (each condition returned) was a direct result of the truth table. Had we gone with a more classical approach, it would have likely resulted in a fair bit of cyclomatic complexity or the introduction of more classes to tackle this problem through polymorphism.

As it turned out, we wrote some tests, wired everything up and it worked just like the BA wanted, but could not logically define.

What is NuGet

2011-03-28T13:27:00.000-06:00

After spending some time with Ruby on Rails and the wonderful package management tool RubyGems, I was very excited to hear about NuGet, a .NET package manager that comes bundled with ASP.NET MVC 3. Finally, the .NET community gets a Microsoft supported package manager. The NuGet page has a pretty good description of what it is and why you should care...

NuGet is a Visual Studio extension that makes it easy to install and update open source libraries and tools in Visual Studio.
When you use NuGet to install a package, it copies the library files to your solution and automatically updates your project (add references, change config files, etc). If you remove a package, NuGet reverses whatever changes it made so that no clutter is left.

You can think of it as a much more convenient way to include third party libraries if you haven't used something like ruby gems before. As a package manager, NuGet will do many things for you to make your life easier.

First, it makes it simple to find and include a library. You don't have to google for the library, find the project page, find the download page, find the right version, etc... You can easily install the package the way you would a local library (almost).

It will pull in dependencies for that library. Want to use Fluent-NHibernate? Just grab the NuGet package and it will include NHibernate, along with NHibernates own dependencies.

It can also allow the injection of useful template code into your project to help get you started. MVCMailer does just this to help get you started with sample views and mailers.

If this sounds worthwhile, head over to Justin Etheredge's blog and follow his tutorial, which is really good.

Also be sure to check out some of the available packages in the NuGet Gallery.

PURE HTML Templates

2010-05-26T21:56:00.001-06:00

I’ve been pressured into writing about PURE templates by a couple of my colleagues at ThoughtWorks. My blogging has died down after rolling off my previous iPhone project, but while doing some work in ASP.NET MVC I came across something useful. A very nice HTML templating engine.

My biggest complaint when looking at HTML templating engines is that they are very similar to PHP or ASP code, littering my HTML with different forms of placeholders. They are very simple and quick to pick up, but very limited once you need to do something more than map A onto B without creating a lot of one off functions that will fit in one line.

<script type="text/html" id="item_tmpl">
  <div id="<%=id%>" class="<%=(i % 2 == 1 ? " even" : "")%>">
    <div class="grid_1 alpha right">
      <img class="righted" src="<%=profile_image_url%>"/>
    </div>
    <div class="grid_6 omega contents">
      <p><b><a href="/<%=from_user%>"><%=from_user%></a>:</b> <%=text%></p>
    </div>
  </div>
</script>

Introducing PURE Templates

Have a look at this fully functional example (view source) using PURE. There is some HTML and a small script block. In the block is a javascript object literal representing the data and a single call to PURE giving the root of the HTML template and the data to render. Clean HTML, very little code and no dirty template placeholders. This shows that, in the happy day scenario, PURE is very simple and easy to use, like most other templating engines.

However, as the web becomes more and more about creating and interacting with services. Consuming third party sources becomes necessity and those sources will not be providing data in the human readable format your require, nor will their names be exactly what you need.

For these situations, we need something more powerful than all these happy day templates can provide (assuming you don’t just want to remap everything you consume). In PURE, they accommodate this by way of a Directive. At a basic level, a directive is a javascript object literal defining how to map your data onto your HTML. The keys are CSS Selectors and the values are Actions, where Actions can be strings, objects or functions.

  <!-- HTML template -->
  <ul>
    <li></li>
  </ul>

  <script>
    var data = {
      legs:4,
      animals:[
        {name:'dog', legs:4},
        {name:'cat', legs:4},
        {name:'bird', legs:2},
        {name:'mouse', legs:4}
      ]
    };

    //declaration of the actions PURE has to do
    var directive = {
      'li':{
        'animal<-animals':{
          '.':'animal.name'
        },
        sort:function(a, b){
          return a.name > b.name ? 1 : -1;
        },
        filter:function(a){
          return a.context.legs === a.item.legs;
        }
      }
    };

    // note the use of render instead of autoRender, and the 2nd argument
    $('ul').render(data, directive);
</script>

source

The above example shows what a directive looks like while consuming data that must be iterated over. It also shows how the directive can accommodate sorting and filtering, which can come in handy at times. If you like what you see, check out the rest of the demos or the tutorials.

Objective-c Inheritance & Message Passing

2010-03-29T22:25:00.001-06:00

Came across an interesting result while overriding a base class last week. Assume we have a class with two methods, one overloading the other as follows.

Assume both methods are defined within the interface (intentionally public). Now when we inherit from this class and override the first method (create:id), where does the "create:int" message in the second method get passed too? It is calling "self" from the context of the parent, but we just overrode the method in the child.

Given the above, where does the message go? Will it call create:id on the child or the parent?

Turns out, it is all in what you declare within your interface for the child. Define

in the child interface and it will pass the message to the child (using your override). Don't and the message will instead go to the parent. Thought it was very curious behavior as a C# guy.

Objective-C Libraries and Tools

2010-03-06T07:14:00.001-07:00

There are quite a few open source cocoa touch libraries and frameworks.

OCMock, the winner by default when it comes to mocking in objective-c. It is actually a really decent mocking framework with all the elements you would come to expect (mocks, stubs and partial mocks). Setting it up can be a bit of a pain, fortunately Colin Barret has figured that out for us already.

Google Toolbox, augments the SenTestingKit (OCUnit) providing more assertions, log tracking, binding testing and more. A very visual tutorial on setting up Google Toolbox.

GHUnit, I am still spending time with this one. Seems promising so far. Key features are running individual tests, running tests from the command line (easier) and testing macros.

UISpec is a test automation tool. It’s key feature is that it can run automation tests within the simulator (OCUnit must deploy to the iPhone). Documentation is pretty sparse.

ASIHTTPRequest is a library that wraps the CFNetwork API, handling quite a bit of the grunt work for you. Great for working with RESTful services.

json-framework, another key element of working with RESTful services. JSON is lighter weight and uses key-value pairs to represent data. This plays very nicely with the KVC techniques you should be using in Cocoa.

SpeedLimit, this is a great utility for simulating the network speeds you are likely to have on the iPhone.

IPhone Development Guide

2010-03-02T22:10:00.001-07:00

Just a collection of information and useful advice that I have collected. Hope this helps you get started.

Start where I started doing something simple hello world type examples. All of the icodeblog tutorials are worth doing if you are starting out (though watch out for the SQLite ones as Core Data replaces that now). Try this one to get a feel for interface builder and this one next for tying the code into IB. It can take a little while to learn the name of the different controls you will be using. This tutorial is on one of the navigation controls, the UITabBarController, which visually rests on the bottom of the window and will be one of your staples.

Cocoa has a learning curve of its own, get up to speed on Key-Value Coding (further reading), the framework makes use of many dictionaries. There is also a good post (with even more links) on the MVC Model used on the iPhone. It differs slightly from other representations of the Model View Controller pattern.

source

The primary difference is in the behavior between the different flows back to the view. On the iPhone, only your controller should be interacting with the UIView where as traditionally it is acceptable for the Model to have some interactions (Notifications or checking state).

Matt Gallagher’s blog is probably something that you want to subscribe to. A few of my favorites:

30 Days of iPhone Development

2010-02-23T23:10:00.001-07:00

Having programmed professionally in C# for the last four years, something new was certainly welcome. I decided to give objective-c a month before really expressing my opinions of the language, so it doesn’t come off as, “I hate it, it isn’t what I am familiar with”. Since I have done objective-c almost exclusively for the last month, so give me some credit.

The IDE

Xcode described in one word would be, sufficient. It gets the job done and if you are running Snow Leapord version 3.2 is a bit better than 3.1.2 (Leapord) that I am running. The differences are minimal though. My major gripes are that xcode uses something called “groups” which look like folders, but are not. You can “group” your code into actual files and they will look the same, but you have to do that on the command line (or Finder), which is a bit unexpected. So assuming you didn’t know that and had been working on a project for a while it could look something like this.

Bit disappointing to see that mess when you assumed you had created some sort of order in all the chaos. Also, files are not listed alphabetically. You can have .m files listed before the .h or after. Whatever strikes your fancy.

The Debugger

I don’t really mind the debugger and it can be really helpful for… well… debugging. It’s good, honest. However, Xcode loves putting everything into its own window, so the debugger is not on the same page as your coding window (akin to eclipse). This is done so things like console output, stack trace and variables in scope can be displayed, but it still feels vastly inferior to the Visual Studio debugging experience where that kind of information is pulled in during debugging, but context remains the same.

Also, whoever decided the break points needed more than one state needs to be shot. Seriously, why would I want a breakpoint that the debugger won’t enter? There is undoubtedly some way to change this, as the forcing save alert before running and undo alerts can be done away with, but I have not found it yet. In the meantime, it means I need to add breakpoints and re-click them if I start coding and need to debug the same piece of code again. You know, try something, debug, it fails, try something else, debug the new solution.

Note: Undo trick is in user defaults.

defaults write com.apple.Xcode XCShowUndoPastSaveWarning NO

Header Files

Having little real experience with C/C++, header files are not something I have ever really had to worry about. All I can say is they are huge waste of time. People complain about unit testing, but these are worse and with none of the benefits. I understand why they have to be written in C/C++, but the thing is you don’t even need them in objective-c. They are there to prevent warnings and give guidance on how to use your code. Essentially nothing is private, so you have to be careful what you show (hence header files). Below is an example of a “public” method called logMySimpleString.

#import <UIKit/UIKit.h>

@interface MyClass : NSObject {
	NSString *aSimpleString;
}

- (void) logMySimpleString;

@property(nonatomic, retain) NSString *aSimpleString;

@end

@implementation MyClass
@synthensize aSimpleString

- (void) logMySimpleString {
	NSLog(@"%@", aSimpleString);
}

@end

Objective-c 2.0 includes support for auto properties, you can see one declared above. Aside from how obviously useless the header file is, look at the three places I have to reference aSimpleString to have an autoproperty. While nicer than writing the getters and setters by hand, it still introduces a lot of repeat code that offers very little value.

Templates and Customization

Finally, more of the positive! Templates for files and projects in xcode are pretty easy to accomplish. This post covers it pretty well, but if you are familiar with ReSharper templates, they are almost as easy and certainly the same fashion. You have to put them into an Xcode/user directory which is unique for iPhone SDK elements (see below).

/Developer/Platforms/iPhoneOS.platform/Developer/Library/Xcode/File Templates

To its credit, most of Xcode is pretty customizable with really good short-cuts. You can define your own in preferences.

Objective-c!

Objective-c is a superset of the C language, so you can both include and use C/C++ code along with your objc code. Yea… that wouldn’t sell me on it either… Sometimes this means you can include useful libraries, but mostly it just means some of your code will go off into some foreign and scary land.

Fortunately, this new language comes with a completely different framework. Coming from ASP.NET/WinForms background, I am very pleased to be working in an MVC pattern which is really well implemented for the iPhone. I also love the observer pattern via NSNotifications. I’ll probably do a post on that next as they are pretty slick.

There is a good document on the apple site on other patterns common to cocoa. There is also a good one on implementing a singleton, which you’ll need if you don’t want to create Big Ball of Mud in your AppDelegate.

I’ll probably continue this later with an observer example using NSNotifications and talk more about how some of the Small Talk elements work within Objective-c.

StackOverflow - Garbage In, Garbage Out

2010-01-21T08:07:00.002-07:00

I have been using stackoverflow for over a year now. It surprises me how great the answers you can find there are and in some cases, the pure quality and effort some individuals will put into them. Take this iPhone question for example.

A stackoverflow user is asking a question about the best way to pass data to ViewControllers in the iPhone (Which uses MVC for its UI). The top answer there is both informative and useful in that it provides a concise answer, as well as, example code to get the user started. Obviously this question took time out of someone else's day to think about and reply, then edit and update. Truly a wonderful example of the simple yet highly valuable resource stackoverflow can be.

Then you get questions like this one. I've seen that question both asked and answered over and over for years now. I've even asked it myself at one point and let me just say that providing an explicit answer to that question never did me any favors. The question is born out of looking for the wrong solution. The stackoverflow user, in this case, is looking for the wrong solution and getting it handed to him on a silver platter.

This is just like using a calculator, they always give you an answer, they don't always give you the right one. Stackoverflow is full of people eager to give you an answer to your question, but no one will spend the time questioning the origins of it.

sp_help

2009-12-10T04:09:00.001-07:00

I am ashamed to admit I never knew about the sp_help and sp_helptext commands in sql server until today. Why has no one ever shown me this earlier?

sp_help will find a stored proc by just providing its name. It will then show all the matches, where they are located and what parameters they take.

sp_helptext will something similar, expect it will display the actual stored procedure. Much easier than hunting through a list.

Programmer Professionalism

2009-10-27T08:27:00.001-06:00

I repeatedly hear, as a programmer, that I should be concerned with my overall professionalism. I should be concerned with the quality of what I produce, the knowledge and experience that I have obtained through work and education and the attitude I bring towards solving complexity.

I should be a professional, no different than say a doctor, a lawyer or an engineer. Engineer is even in my title, it is so clear.

On the other hand, I also feel that I should be more like a tradesman or a craftsman. Learning under a master on a linear path that never ends, always improving.

Here is an analogy that I used to describe programmer to my father, a tradesman.

Working as a programmer is not too dissimilar to building a house. There is an initial design, planning of the work, sign-off on everything and then the actual building commences.

Only recently have we started practicing the fact that the user must be involved if we want to succeed. The strict set of rules to follow in design are always changing, especially if the designer is constantly self improving, as they should be.

Programmers must both design and build the systems they work on. They are a tradesman (builder) and a professional (designer). With all these different expectations and the only constant being change, it would be surprising if one person was capable in one of these directions.

We will probably never have a clear Apprentice to Journeyman to Master tradesman approach nor a professional accreditation. What we will have is the highest expectations any career has known and so much change that we will never be able to agree on things of consequence.

Object-Oriented Design Basics

2009-10-22T11:27:00.001-06:00

In order to achieve each of the metrics defined previously we can employ some very fundamental techniques. Techniques that should appear to be common sense, hopefully. Though broad in scope and concept, they are the basis for much of what we currently try to achieve in programming.

Abstraction

The notion of abstraction is to distill a complicated system down to its most fundamental parts and describe these parts in a simple, precise language. Typically, describing the parts of a system involves naming them and describing their functionality. For instance, take a design pattern such as the Abstract Factory. When I use this pattern, declaring its name in the class definition, I am telling the next programmer what this class is supposed to do without documentation and without comments. When I declare some class called, CarFactory, a programmer should know that an instance of this class with provide instances of Car objects.

Encapsulation

Another important principle of object-oriented design is the concept of encapsulation or information hiding. Encapsulation means that different components of a software system should not reveal the internal details of their respective implementations. In general terms, the principle of encapsulation states that all the different components of a large software system should operate on a strictly need-to-know basis. There is a common saying surrounding this, “TELL, DON’T ASK”.

One of the main advantages of encapsulation is that it gives the programmer freedom in implementing the details of a system. The only constraint on the programmer is to maintain the abstract interface that is visible. Encapsulation aids in adaptability because it allows the how to change without altering the expected outcome.

Modularity

In addition to abstraction and encapsulation, a principle fundamental to object-oriented design is modularity. Software systems typically consist of several different components that must interact correctly in order for the entire system to work properly. Keeping these interactions straight requires that these different components be well organized. In the object-oriented approach, this structure centers around the concept of modularity, which refers to an organizing structure in which different components of a software system are divided into separate functional units.

The structure imposed by modularity helps to enable software reusability. If software modules are written in an abstract way to solve general problems, then modules can be reused when instance of these same general problems may arise under a different context.

Problematic Processes

2009-10-15T17:02:00.001-06:00

I have always disliked following process for the most part. There is something dehumanizing when I enter into the conversation where I am told about some event and then told what I am expected to do. I understand what processes are in place for in the broader sense and often try to discover the particular reason for each process before I will follow it. Generally though, the employer wants workers A through Z to all behave in a similar fashion. Why though?

Consistency. If all your workers do the same thing, then they will be consistent in their day to day work. This also means they are predicable and replaceable. Each worker is desired to be a replacement for any other as long as they follow the same processes. Is that a good thing?

In some case, I would argue yes it is. There was a time in my life when I worked on an assembly line and process would make or break the productivity. Each day followed a specific process, breaks followed a process, each task always had a specific and predicable process. When the feeder has space, put in another tray. When the pallet of trays are gone, get another pallet. Very rudimentary process that is basic and practical. Often this process is the discovered best techniques of what you are supposed to be doing and essentially giving you the optimized way to do each task. Do this because it has proven to be the fastest or most maintainable way of doing things. Great I say.

However, bureaucratic process is a whole different beast. The domain is larger, the number of employees usually greater and the types of tasks being done much more complex. Process in this case is often more to do with getting each groups interests met rather than providing the most efficient or maintainable way of doing things. That is the part I dislike. A giant muddled mess of wide concerns, each at a different level of importance based entirely upon your current job, department and/or pay grade. Yuck.

Thinking about how many concerns are no longer valid or important will only depress you further. How much of your day is spent doing tasks that don’t provide any benefit to you, your employer or your employer’s customers. You can tell things are bad when you ask, “Why do we do X?” and you get a response such as, “Because legal wants us to” or worse, “Because I told you to”.

Quality Time

2009-09-25T10:49:00.001-06:00

In case you didn’t know, there has been a round of squabbling going because of Joel Spolsky’s post on Duct Tape Programmers. Robert C. Martin (Uncle Bob) has a good response that argues against shipping low quality code. Everyone else is trying to make this into a dichotomy, though it simply feels like one individual puts more priority on release date, while the later puts more priority on code professionalism. Maybe it is because of the recession, but both could be happy if we could just throw more resources at it, in theory.

The age old idiom, show the above triangle, agree that Quality should be high, while Cost and Time should be low. Then you say, “I know all three are desired, but please only pick two”. Money must be limited on most projects these days, reducing the question to priority on Quality or Time?

Since Uncle Bob is a huge proponent of TDD, his main focus for quality is surrounding unit testing, while Joel is focused on individuals that can make nearly anything “work” quickly. Joel shrugs off unit testing as a lofty goal for academics and Uncle Bob focuses more on the common ground between the two and agreeing simplicity should be favored.

Personally, I see the relationship as follows.

Shipping Late > Shipping Shit > Not Shipping

Not shipping or not writing a hack or two to get the product out the door is your worst option. If the product doesn’t go live, all your effort is for nothing. However, hacking the entire thing out the door because proper design and testing takes too much “Time” is only going to paint you into a corner. Sure you will ship something faster than your competitors and maybe that is all your care about. You must consider some important things before saying all that matters is time. Will your customers want to use it? Probably not. Will the developers want to maintain and enhance it? Probably not.

Clearly Time and Quality are important, otherwise they wouldn’t be on the triangle. The key is to balance them appropriately, which is what most individuals are saying. Zealous animosity against or for unit testing aside, the entire argument is subjective. Consider what your demands are and plan appropriately.

Unicode Transformation Format

2009-09-17T03:33:00.000-06:00

Had another one of those days yesterday where you get deep in discussion about some of the nitty gritty. This time it was surrounding Unicode and though I knew some pieces of the picture, I could have certainly done with more information.

First and foremost, Unicode is a way of encoding characters as a sequence of bytes. In this case, characters (and even more so strings) are an abstraction. UTF-8/16/32 define different encoding schemes that we can use for those bytes. Each of those bytes are being represented by one hexidecimal value.

source

Looking at the UTF-8/16/32 section of the diagram, we see the different byte representations of the three characters. Also notice that UTF-8 byte representation of 'A' is identical to ASCII. This is true for a large set of the Latin alphabet and ties into why UTF-8, in Latin languages, is usually the most compact Unicode encoding choice. For this reason, storage and data exchange systems prefer it.

C# for example uses UTF-16 encoding for strings, but will default to UTF-8 for streams. UTF-8 isn’t all good though and it should be noted that UTF-8 is significantly more complex to process than UTF-16 because lead bytes have a relatively complex encoding and up to three trail bytes must be counted. This is due to the fact that Unicode is optimized for 16 bits.

If this interests you, the below documents provide even more insightful information.

Unicode Technical Notes

Unicode is not UTF-\d{1,2}

Python Document on Unicode

Object-Oriented Design Metrics

2009-09-16T03:32:00.000-06:00

I have had many discussions with colleagues and friends about the different things we value in software. Why we favor one thing over another, why we implement something a particular way, etc… However, I have also had numerous discussions with developers whose values differed drastically to my own. Arguably, many of these values can be subjective, and when we both reached that conclusion the argument became simply an expression of what we favor and why.

For example, how can you argue the value of something like the single responsibility principle [pdf]? Ask them if they agree and call them an idiot if they say no? Ad hominem has hardly proven to be an effective argument technique. So what do you do to effectively introduce new ideas and argue their value when the other party just keeps asking why that has value?

The technique that has worked for me, in discovering why someone feels a certain way about a principle, is to break everything down to very basic parts that are nearly universally true and introduce your idea under those truths, explaining how it affects them positively. These pieces must be so small that to challenge them would signal the warning signs that the individual is ignorant of the subject matter or intentionally breaking it. In the case of the later, this gives you an ideal platform to challenge why the decision was made and why it is or is not valid. This is more than saying SRP is good because it improves code quality. You must get to the heart of everything, including code quality. And this is where I wish to begin, with OOD metrics that I feel are universally true.

The measure of quality software is more than simply achieving the list of requirements on a specification document. The design of the software itself is equally, if not more so, paramount to the overall quality of the software. In order to properly design complex systems we must have metrics by which to judge that design. These metrics should be so fundamental that they appear to be common sense.

Robustness

Every good programmer wants to produce software that is correct, which means that the program produces the right output for all the anticipated inputs in the program’s application. In addition, we want software to be robust, that is, capable of handling unexpected inputs that are not explicitly defined for its application. For example, if a program is expecting a positive integer and instead is given a negative integer, then the program should be able to recover gracefully from this error. A program that does not gracefully handle such unexpected-input errors is not robust and can be embarrassing for the programmer.

Adaptability

Modern software projects will typically involve large programs that are expected to last for years. Software, therefore, needs to be able to evolve over time in response to changing conditions in its environment. These changes can be expected, such as gradual hardware improvements, or they can be unexpected, such as new requirements. Software should be able to adapt to unexpected events that, in hindsight, really should have been expected. Thus, another important goal of quality software is that it achieves adaptability.

Reusability

Going hand in hand with adaptability is the desire that software be reusable, that code should be usable as a component of different systems in various applications. Developing quality software can be an expensive enterprise, and its cost can be offset somewhat if the software is designed in a way that makes it easily reusable in future applications. Such reuse should be done with care, however, for one of the major sources of software errors can come from inappropriate reuse of software. This means software must also be clear about what it does and does not do. From this clarity, however, software reuse can be a significant cost-saving and time-saving technique.

Technical Debt

2009-09-04T03:04:00.000-06:00

Technical Debt is a metaphor coined by Ward Cunningham. It refers to anything that isn’t done right during development. This includes things like breaking coding rules, introducing potential defects, increasing code complexity, code duplication or even ignoring necessary documentation. We’ve all been through crunch time and when something needs to work and work right NOW, the ends begin to justify the means.

There are quite a few sources describing technical debt, why it is bad, ways around it. There are even applications that try to calculate the actual cost of your technical debt.

It is funny all the ways developers need to “trick” management into appreciating elements of our craft. I cannot remember the last time I spoke to a developer about the monetary cost of using something as fundamental as SOAP vs REST. Yet, here we are, trying to make developers care about the actual value to the company of things with the hope that developers caring about budget and cost will somehow get management caring about the code.

I mean, sometimes technical debt makes sense. Startups are rarely known for their innovative programming improvements and more for their innovative programming. That isn’t to say startups can’t produce elegant code that is a pleasure to work on and easy to enhance. Some probably do, but those that try, likely don’t last long. When you are a startup, money is tight. A few dollars of incurred technical debt today are easily covered by the billions you will be worth in the future...

At least you get to wear a hat afterwards.

The real problem with technical debt, even for startups, is that most developers are perfectionists. A study done (link) found that…

87.3% of respondents believe that delivering high quality is more important than delivering on time and on budget.

Not only is that number high, but it was the highest factor when compared with scope, time, staff and money. For me, this says that not only is technical debt bad for the code environment, but it is just as bad to the programmer’s environment and morale.

That is exactly why SCRUM sometimes includes a refactoring backlog to be worked on after releases, as much for improving the code as improving team morale. There are few things more rewarding than slaying dragons. Code dragons that is.

If you want to read more about technical debt, read this article. It really does the best job I have seen analyzing technical debt from both developer/management perspectives, as well as, what is really important about technical debt.

UPDATE: It appears someone else was thinking about technical debt.

Available here.

Too Many Articles

2009-09-03T18:57:00.001-06:00

Did you ever want access to over 80 different articles on programming ranging from SRP to code bombs?

Me too!!

link

Predicates

2009-09-02T03:00:00.000-06:00

I love predicates. They are a rather recent addition to my toolkit, but already I use them every time I can. What is a predicate you ask?

A predicate is a piece of logic to affirm or deny the subject of a proposition. Programmatically, a predicate is a function that returns true or false when given a class or value. For example.

     public bool Contains(IProduct product)

    {

        Func<IProduct, bool> predicate = x => x.Name == product.Name;

        foreach (var item in products)

        {

            if (predicate(item))

            {

                return true;

            }

        }

        return false;

    }

Pretty cool, but let’s get rid of that foreach.

    public bool Contains(IProduct product)

    {

        Func<IProduct, bool> predicate = x => x.Name == product.Name;

        return products.FirstOrDefault(predicate) != null;

    }

And finally…

    public bool Contains(IProduct product)

    {

        return products.FirstOrDefault(x => x.Name == product.Name) != null;

    }

We can also filter lists in a similar fashion using Where

    public IEnumerable<IProduct> FindByName(IProduct product)

    {

        return products.Where(x => x.Name == product.Name);

    }

Update: Thanks to Conrad for helping me improve this and remove the need for an Extension Method.

Gzip Issue

2009-09-01T08:10:00.000-06:00

A co-worker was facing down a problem with one of his asp.net portals last week and asked for some help. The full details about what this portal does are not important, but suffice to say that it would zip up some files on the server and allow users to download them.

The problem was that on one of the two servers where this portal was hosted, files were coming down smaller than the other and failing to unzip. It almost appeared that the last 5-8KB of the files was just being truncated. I spent a fair amount of time with this person checking the versions were consistent, that the configuration files were consistent and that basically nothing was wrong on the developers end.

At this point we were ready to point the finger at IIS, but we needed to be sure.

I logged onto the failing server (this is in dev), ran inetmgr and compared the IIS settings to the working server. Aside from a few false leads, everything is more or less that same. The particular site is running as a virtual directory, all the usual settings look like carbon copies of one another (security, permissions, thread pool, .net version, etc…) and nothing appears to be out of place.

At this point we are starting to think it must be in some part of IIS we were not familiar with and decide to give fiddler a try on the user’s end instead. For those that are unfamiliar with fiddler, it is a lot like wireshark except it plugs directly into internet explorer and captures all the network traffic in a much more friendly and active way. I ran into this tool a couple of years ago and it has remained in my toolbox since.

Request header for the working server.

Request header for the failing server.

Other than different session ids, they are identical.

This was the response header from the working server.

This was the response header from the failing server.

Notice the difference? If somehow you missed it, the transport mechanism from the server to the client is using gzip on the failing server. I decided to disable it for that server to see if it would fix the issue as a proof that the issue was with gzip compressing the zip files.

A quick way to disable something for gzip compression is to check if the file extension you don’t want compressed is included in the MetaBase (IIS configuration file).

The tag you want to look for is IISCompressionScheme

There is a decent step by step guide on enabling gzip compression here. The biggest tip is that you need to shut down IIS before editing the MetaBase file. There is an option to do this in the restart procedure.

That all said and done, it was indeed gzip that was causing the issue. It really shouldn’t matter if the content is compressed between the server and the browser, but for some reason none of the major browsers would uncompress the file. Another issue for another day I suppose.

Blog Migration

2009-08-30T13:35:00.001-06:00

What better way is there to spend a Sunday afternoon than migrating old data…

I am just happy that it is done. I’ve also migrated an old domain so that blogspot can use it. Enjoy viewing my blog from codecuriosity.com instead of codecuriosity.blogspot.com

Simpson’s Paradox

2009-08-28T13:53:00.001-06:00

According to Wikipedia, Simpson’s paradox is an apparent paradox in which the successes of groups seem reversed when the groups are combined. Often encountered in social and medical science statistics when frequency data are given causal interpretations.

That probably did as much for you as it did for me when I first read it. Let’s look at the example.

There are two departments (Department A and Department B). Each department receives an equal number of male and female applicants. Of the 510 male applicants, 251 men were accepted and of the 510 female applicants, 109 women were accepted. That means for 360 positions, men took almost 70% of the positions. Initially, this seems like a clear cut case of sexism in favor of men.

However, when the departments are analyzed individually we find that department A had 500 male applicants and only 10 female applicants. Of the male applicants, 50% were accepted while 90% of the female applicants were accepted. In department B, 10 males applied and 10% were accepted, while 500 females applied and 20% were accepted.

What is the result? Overall we see men taking 70% of the available jobs, yet department A favored women by 40% over men and department B favored women by 10% over men. Now it appears that we have sexism in favor of women.

	Men	Women
Department A	500 applicants (50% accepted)	10 applicants (90% accepted)
Department B	10 applicants (10% accepted)	500 applicants (20% accepted)
Totals	251 accepted	109 accepted

How is it that two departments, both favoring women, resulted in men taking more jobs than women? It is all about where the majority of each sex put their application. In the case of the male applicants, most applied to a department that had a much greater hiring rate.

There are some other great examples, one in particular where something quite similar to the above occurred.

Instant Django

2009-08-27T15:06:00.001-06:00

Came across a very easy to set up Django environment. No install, one file to download and only configuration for whatever you want to run as a configuration requirement. You can even set this up to run off of a flash drive, which I thought was pretty sweet.

Instantdjango should be able to start you on your first django web app in under 30 mins on most windows machines with no other pre-requisites.

There is also a hand holding guide from beginning to end targeted at very beginner level audience. Now back to tweaking my crime map.

Web Related Links

2009-08-27T07:48:00.001-06:00

I have a terrible tendency to accumulate bookmarks and not get the chance to go back and properly implement or use the article in question. In this case, that has more to do with spending little or no time on my web skills (HTML/CSS/Javascrip) in the last three months. Sure I have done some web work, but my spare time has been primarily on other things.

The first is a monstrous link dump on CSS techniques including obvious css related topics such as Page Layout, Menu/Navigation, Typography and others. Now perhaps you are not Max Kerning and typography doesn’t concern you more than life itself. Covering ways to avoid click jacking is also a good touch.

link

The second is something I came across after doing something similar myself. I’ve always disliked ASP.NET web forms, especially the XML tag soup and bloated code behind involved in forms validation (and most things). Something like this isn’t too difficult to implement, provides much more direct and immediate feedback to the user and can use server side validation to validate the data on the client side (validate it again just to be sure on submit though)

link

The last is very design centric, which is something I have never been very adapt at. Sure I can make something good, but it always feels like it takes longer than it should. Creating new sites from scratch is something I usually try to defer to something like free-css-templates. In any case, learning how to do this on your own is certainly a valuable skill when you cannot just reference someone else’s work and do away with hours of your own.

link

ReSharper Shortcuts

2009-08-26T13:27:00.001-06:00

I’ve been a huge fan of ReSharper since I first started using it almost 6 months ago. It takes time and effort to make the most of any tool and ReSharper is no different. That said, the benefits are paid back ten times over with a tool that rarely lets you down. As I’ll likely bring up ReSharper in the near future, I’d like to post my favorite shortcuts. I can look at features like live templates or issues like memory usage another time.

Ctrl-Alt-T	Bring up unit test explorer
Ctrl-E	Lists files in order of last access
Ctrl-N / Ctrl-Shift-N	Open type / Open file (SystemInfo can be found by shortcut SI)
Alt-Shift-L	Moves focus to currently open file in the solution folder
Ctrl-Shift-G	“Super Go”, brings up usuage, declaration, base, more…
Alt-Insert	Code generation, constructor, implement interface, more…
Ctrl-Shift-R	Refactoring options, rename, move, extract, pull up, more…
Ctrl-F6	Change method signature.
Ctrl-Shift-Alt-Arrow Key	Move item up or down, including whole methods