Posted by: jsonmez | February 9, 2012

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.


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.


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.


  1. […] The Development Pendulum – John Sonmez discusses what he refers to as the ‘Development Pendulum’, the nature of our industry to oscillate from one extreme to the other on most topics, and how this action drives the industry forward. […]

  2. Nicely put. Personally, I don’t mind being 5 years “behind”. Because then, the pendulum won’t swing as much anymore and I can have a pragmatic view on what will really matter in the future without changing my paradigms entirely every time I move on.

    Example: SQL vs NoSQL. The current debate is really ridiculous as the only accepted positions are “extreme”. It’s very likely that both “technologies” will remain and merge somehow…

  3. […] qui un post che affronta un argomento secondo me molto importante per chiunque si ritrovi a fare il mestiere […]

  4. […] The Development Pendulum (John Sonmez) […]

  5. Hegel called this “Thesis, Antithesis, Synthesis.”,_antithesis,_synthesis

  6. I wish you didn’t point these things out. It almost makes me feel silly standing behind some new way of doing things, knowing that either its been done before and abandoned or, it will soon go out of style. 😦 You have a very glass half full way of looking at it.

    • Just don’t hold onto any one thing too tightly 🙂

  7. […] The Development Pendulum […]

  8. Reblogged this on Coding Lifestyle and commented:
    I like waffles too!

  9. An upshot from your post: there are no best practices, as though we could find the ultimate way to solve any particular problem for all time. They are really the best practices we have found so far.

    I think the software community as a whole needs to temper our ego a bit.

  10. Excellent and IMHO accurate observations. I personally believe that much of the churn is a result of wanting to trade engineering for “Best Practice” or “Patterns”. From a CS perspective there are always a multitude of ways to model a process, and there are costs as well as benefits to each. It is our lazy desire to avoid the engineering effort of deciding what is best for a specific case that leads us to want a fixed answer for a class of problem. And human nature is such that when you have a new hammer everything looks like a nail.

  11. Very perceptive. Check out this talk by Dan North – I think you’ll like it

    I think the connection is that the term “Best Practices” is often tied to “what is cool right now”.

  12. This is soooo true. cheers ,,,

  13. Hey John, has anybody told you you’re a dead-ringer for Shane Walsh on the Walking Dead?

    • Nope, hadn’t heard that before. I do see the resemblance though.

  14. […] but I call it progress. Life is a game of overshooting and adjusting. References: The Development Pendulum from our NCG partner John Sonmez at the Making the Complex Simple blog. […]

Leave a Reply

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

You are commenting using your 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 )

Connecting to %s


%d bloggers like this: