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.