Becoming A Better Software Engineer

A Little Background

As software developers we solve problems for people.  A client comes to us and asks us to create solutions.  It is our job to take our knowledge and experience to deliver the best product for their needs.  Like a carpenter, a painter, a surgeon, and yes even like an engineer we have to study and practice and understand our craft in order to deliver.

I recently watched a talk by Patrick Lioi titled Keeping Your Inner Architect On A Leash in which he goes through a sample program with life-like pressures that require the program to change.  These pressures include bug reports, features requests, feature changes, etc.  It is a great walk through of only changing the code according to the amount of pressure you receive and not letting yourself get carried away.

After watching this video I have decided I need some practice in controlling my inner architect.  I sometimes have the tendency to refactor everything.  I think about all the possible problems and obsess over design patterns and clean code and making sure it is perfect.  Now don’t get me wrong. All of these things have their merit, but not at the expense of delivering what is needed when it is needed.  It can especially be a problem in a customer’s code.  They probably don’t want you to change their entire code base and they certainly don’t want you to waste their time or money.

With that in mind I am going to start with a sample client project similar to Patrick’s but with different requirements and see how it evolves.  My goal is to practice controlling my inner architect as well as honing my skills and knowledge of design principles and patterns, refactoring, and delivering what the client needs.

So here it goes.

The Problem

We have a customer who has a problem to solve.  A file containing ten random numbers separated by commas is placed in a folder on a computer at different times.  Unfortunately their Do-What-Ever-It-Does-With-The-File machine cannot do anything with 10 random numbers.  It needs those numbers sorted from least to greatest.  They have hired you to create a program that an employee can run that will do the number sorting.  They can’t leave the task of sorting to a human because mistakes in sorting would be costly.

The Requirements

The client has outlined the requirements in a succinct paragraph.

The program should sort the 10 random numbers in the file from least to greatest and write them back to the same file.  The file will always be in the same place and there will ever only be 10 numbers.

The Design

This seems like a pretty straight forward problem and one that can easily be solved.  The customer requirements are clear, so let’s get to work.  We don’t want to over engineer this thing.  We only want to build to the requirements.

The Algorithm

Here is the algorithm I think will work for the requirements.

  1. Read in all the text of the file
  2. Split up the text into individual numbers
  3. Sort the numbers
  4. Overwrite the file with the sorted number sequence

The Work

Now that we have our requirements and a plan to move forward, let’s move forward with writing the code. According to our defined algorithm the first thing we need to do is read in all the text of the file.  No problem.  First we read in all of the contents of the file at once.  This is standard stuff and .NET has this built in for us.

[gist https://gist.github.com/castever/4b6d9e62ea928bc32b3f]

Next we split the contents of the file into ints using the built in Split method of string.  We need to convert all of this new strings into integers.  We can do this with a standard for loop, parse the string using Int32.Parse, and add it to an array of integers.

[gist https://gist.github.com/castever/37306e71428f2f3f5962]

Sorting is easy enough.  Again the .NET Framework provides what we need: Array.Sort.

[gist https://gist.github.com/castever/4bd56de8ca0b2f1a68ba]

Now we are getting somewhere and closer to completing the requirements of the project.  All we have to do now is write the new sorted array of numbers back to the file. First we create the new text string out of the sorted array of ints by looping through the array with a standard foreach loop adding each int to a string. This will become the new content of the file.

[gist https://gist.github.com/castever/83bb7c7c6d67b8861634]

Finally we write the new content to the same file.  Again, .NET has us covered.

[gist https://gist.github.com/castever/45a3d1c89d81b1165bd4]

And that finishes up the solution.  We have satisfied the requirements of the client, but before we deliver we need to take a step back and see what, if any thing, we can do to this code to follow best practices and deliver a solid product.

Next time.

In the meantime you can get the project on Github.

Advertisements

3 thoughts on “Becoming A Better Software Engineer

  1. Great job! Good clear description of the problem, expectations and the possible solution(s). Clear, concise and to the point. Looking forward to the next one!

  2. I love the structure and organization of this post. The problem was structured simple and concise. The walk through the solution was very simple to follow. It helps me remember I’m not alone in the “over architecture” world. Looking forward to next post.

  3. Architect all the things! Seriously, well written. I can see where you’re going with this, though, and I think I would have just started there rather than iterating through these steps.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s