I’ve been a software developer for over 16 years. It’s not that long but in terms of software development it’s pretty long time. Perhaps it’s like dog years – 1 development year equals 7 normal person years so actually I’ve been a developer for 112 software dev years. That seems more like it.
Over that time I’ve seen 4 major shifts in web development. Shifts up to new versions happen all the time – this is more where everything you know needs to be put in the bin and you start up again. Seems harsh but that’s the business and if you don’t like it then it’s perhaps time to move on. I’m shifting again to Node.js and React but as I do it’s kind of interesting to look back at the other shifts and how I felt about them at the time and how good they were in retrospect.
Classic ASP
It’s where it all began. Asp files with VBScript and <% %> to poke holes in the html to fit the programming stuff in
<!DOCTYPE html>
<html>
<body>
<%
For i = 0 To 5
response.write("The number is " & i & "<br>")
Next
%>
</body>
</html>
It’s all about the response.write. I loved it.
Features
- Interpreted language – no compilation
- Written in scripting language like VBScript or JScript
- One file called *.asp. Everything is in there.
- One file per page
- Lots of use of Response and Request objects. Felt like you were working with the architecture of the web rather than against it
- Stateless
How excited was I to use it?
Ecstatically excited. I loved coding in it. Dynamic web pages that could squirt out content for each individual user. Amazing. It was all interpreted – no compilation here – no need for it. I did this for a Masters project and we all loved it. My supervisor was talking about PhDs in it.
Downsides
It wasn’t perfect. The downsides were
- Terrible IDE. It was MS InterDev and it was unusable. We all used to code in EditPad Pro which at least had colours.
- No structure. You could put COM+ components in to force some structure into it but you would only do this if you really hated your coworkers.
- No debugging unless you count writing acres of Response.Writes all over your code
- No state management at all. You want to persist the state of a textbox then do it yourself …
which sets the stage for
ASP.Net Web Forms
A proper compiled language with a new framework and new languages to boot .To get a flavour here is the ubiquitous page load event
protected void Page_Load(object sender, EventArgs e)
{
if (IsPostBack)
{
Response.Write("<br>Page has been posted back.");
}
}
Felt radical at the time.
Features
- A compiled language – Wow!
- Code behind – split files with markup and code in separate files combined with partial statements
- Highly abstracted – managed through page life cycle events
- Stateful – Automatic state management through View State
How excited was I to use it?
Passed myself with excitement. I got to build a new server first to host it and I had a big silver machine on my desk making a sound like an aircraft for months. And that was just the start – new language, new IDE that worked, proper code and architecture. Who wouldn’t like all this.
Downsides
The world moved past webforms and while they were good initially, the advent of more client side techniques such as AJAX showed it’s limitations
- Worked very badly with JavaScript. WebForms mangled HTML element ids and made it difficult to work with
- It was really like windows programming for the web. While hiding the complexity of the web might seem good I’m convinced that webform programming led to a cohort of web developers who really didn’t understand the nature of the web.
- Inefficient – lots of postbacks and ViewState (stashing the state of the form to persist it) was massive and came over the wire every time.
- Very difficult to unit test. Too many tightly bound dependencies
- In the end I hated some of the components. Some were good like ListView and some were made for abuse and torture such as the UpdatePanel. Nest these babies and watch the bad times roll.
Things looked a lot brighter over at the Rails community so we got …..
ASP.Net MVC
Model, View Controllers in the Net world. It was a proper architectural pattern that was fully unit testable. It wasn’t pretending to be windows programming – it was the web and it was proud of it. Clearly still very much used today.
@{ var theMonth = DateTime.Now.Month; }
<p>The numeric value of the current month: @theMonth</p>
@{ var outsideTemp = 79; var weatherMessage = "Hello, it is " + outsideTemp + " degrees."; }
<p>Today's weather: @weatherMessage</p>
How excited was I to use it?
It wasn’t so much as excited – I was relieved. After fighting against webforms, here was something that worked with you. It was almost back to classic ASP in some ways so I felt like I was coming home.
Features
- Skinny controllers, dumb Views and fat models
- Clever routing so it wasn’t one file per page any more. That more than anything amazed me
- Worked well with dependency injection so was testable
- Worked well with JavaScript. Generally felt like the web
- Stateless again
Downsides
Honestly I just like MVC and always have done. If pushed I might say
- It still posts back so not as responsive as it could be
- It’s a different stack to front end so you would need to know C# and JavaScript
- It’s easy to write badly – massive Views full of logic aren’t good
But while we weren’t looking Node.js was discovered and we get….
React
Or I could have said Angular or Ember or fill in the blank with your favourite framework. For me, it’s the most radical shift yet because it’s not the Microsoft stack – we’re not in Kansas any more. It’s all in JavaScript, even the server. And while it’s not restricted to the client it’s focus is around ‘reactive’ single page applications (well my focus is anyway).
render() {
return<MasterPage>
<Jumbotron>
<h1>Home Page</h1>
</Jumbotron>
<Row>
<Col lgOffset={1}>
<Button bsStyle="primary"onClick={() =>this.showMessage('Danger, danger: high voltage')}>Panic</Button>
<Button bsStyle="primary"onClick={() =>this.showMessage('Calm down, calm down')}>No Panic</Button>
</Col>
</Row>
</MasterPage>;
}
Features
- Highly componentised
- JavaScript with HTML like syntax embedded in
- Single page application (often)
- View only .
- Blazing fast if on single page app – uses Virtual DOM to only update what it needs to on the page
- Back to stateful (if on single page app)
How excited am I to use it?
I feel pretty fortunate to have to opportunity to use this in a commercial setting. I’ve always liked JavaScript and it’s fascinating to see it build out a large scale application. I like Angular for the same reason. So I’m excited once again.
Downsides
It’s not all gravy though. Downsides include
- It is a steep learning curve and fast moving so the curve keeps shifting
- It’s JavaScript which is great but it’s easy to write terrible JavaScript so terrible React
- You’ll need a decent architecture to go with it like Redux – not a disadvantage but you need to be aware of it
- It’s just the view so the rest is up to you to (re)invent.
Looking Back and Looking forward
I feel all misty eyed looking back and this is just one aspect of the development I’ve been involved in. There’s ORMs, mobile development, testability, ASP Core, the rise of Dev Ops and on and on and on. Headspinning but great.
What’s next – it’s just so hard to say. I reckon .Net Core will take off, JavaScript will be replaced or transform to something unrecognisable, everyone will decide they hate ORMs and rediscover stored procedures, machine learning will be big, driverless cars will start to fly and we will all go to live on Mars with Elon Musk. Or maybe someone will invent a web framework which combines the best of classic, web forms, mvc and react; perhaps like this ……
- The simplicity of classic ASP
- The rapid development capabilities of web forms
- The testability of MVC
- The blazing speed of React
Can someone invent that one please.
Useful Links
https://www.w3schools.com/ASp/asp_examples.asp
Classic ASP examples
https://msdn.microsoft.com/en-us/library/ms178472.aspx
WebForms page management life cycle
https://www.asp.net/mvc
Microsoft site for MVC
https://reactjs.org/
Main page for react from FaceBook this time
2 COMMENTS
LEAVE A RESPONSE
Love it. As an old classic ASP developer now trying to move into .Net Core and Blazor. This really does sum up the experience. It’s not been pretty or, at times, comfortable, but it’s been a ride! xD
Best of luck with Blazor. The wheel turns again!