The Development Pendulum

I’ve noticed a rather interesting thing about best practices and trends in software development, they tend to oscillate from one extreme to another over time.

So many of the things that are currently trendy or considered “good” are things that a few years back were considered “bad” and even further back were “good.”

This cycle and rule seems to repeat over and over again and is prevalent in almost all areas of software development.

It has three dimensions

Don’t misunderstand my point though, we are advancing.  We really have to look at this from a 3 dimensional perspective.

Have you ever seen one of those toys where you rock side to side in order to go forward?

Software development is doing this same thing in many areas.  We keep going back and forth, yet we are going forward.

Let’s look at some examples and then I’ll tell you why this is important.

JavaScript!

Is JavaScript good or bad?

Depends on who you ask, but it is definitely popular right now.

If we go back about 5 years or so, you’ll get a totally different answer.  Most people would suggest to avoid JavaScript.

Now, JavaScript itself hasn’t changed very much in this timespan, but what has changed is how we use it.

We learned some tricks and the world changed around us.  We figured out how to solve the biggest problem of all for JavaScript…

Working with the DOM!

JQuery made it extremely easy to manipulate the DOM, the pain was removed.

Yet, new pains emerge, hence backbone.js is born.

Thick client or the web?

Take a look at how this has changed back and forth so many times.  First the web was a toy and real apps were installed on your machine.

Then it became very uncool to develop a desktop app, everyone was developing web apps.

But soon we ran into a little problem – those darn page refreshes.  Gosh!

So what did we do?  We sort of made the browser a thick client with AJAX.

That created so much of a mess that we really needed clean separation of views from our models and our logic (at least on the .NET side), so we went back to rendering the whole view on the server and sending it down to the client with MVC.  (Yes, you could argue this point, but just pretend like you agree and bear with me.)

Then we decided that we needed to start moving this stuff back to the client so we could do much more cool things with our pages. We started pumping JavaScript into the pages and ended up creating thick clients running in browsers running on JavaScript and HTML5.

And now we are seeing traditional thick clients again with iOS and Android devices and even those will probably eventually migrate to the web.

Simple data vs descriptive data

Check out this sine wave!

First we had fixed-length records where we specified the length of each column and exactly what data went there.

Then we moved over to CSV, where we had loose data separated by commas.

Then we thought XML was all the rage and beat people up who didn’t define XSDs, because data without definition is just noise you know!

Now we are sending around very loosely structured JSON objects and throw-up whenever we see angle brackets.

So many other examples

Take a look at this list:

• Static vs dynamic languages
• Web services ease of use vs unambiguity (SOAP and REST)
• Design upfront vs Agile (remember when we just wrote code and deployed it, it was kind of like Agile, but different)
• Source control, constant collaboration vs branching
• Testing and TDD
• Databases, stored procs vs inline SQL
• <% %> vs Controls
• …

It goes on forever

So why is this important?

It is not just important, as a developer, it is CRITICAL for you to understand.

Why?

Because whatever happens to be “cool” right now, whatever happens to be the “right” way to do things right now, will change.

Not only will it change, but it will go the complete opposite direction.

It won’t look exactly the same as it did before – we will learn from our previous mistakes – but it will be the same concepts.

Advancement follows this sine wave pattern.  Don’t try and fight it so hard.

You have to be balanced.  You have to be able to understand the merits, strengths and weaknesses of both sides of a technology or best practice choice in development.

You have to understand why TDD improved our code until it led us into overuse of IoC and pushed C# and Java developers to the freedom of dynamic languages like Ruby.

You have to understand that eventually the course will correct itself yet again and head back to the direction of the new static language or even an old static language that will be resurrected.

This is how you will grow

It is also very important to realize that this is exactly how you will grow.

Just as the technological world around you is in a constant forward progressing pendulum swing, so are you, at a different pace, to a different beat.

I know that through my personal development journey, I have switched sides on a topic countless times.

You might call me a “waffler,” but I call it progress.

Life is a game of overshooting and adjusting.