Category Archives: Software Engineering

Lunch’n’Learns – Aspect Oriented Programming and Jon Skeet Abusing C#

Covering the last two lunch’n’learns in one post here, our January video of choice was about Aspect Oriented Programming. Put forward by one of our team in the end the general feeling about the approach was a muted and a challenge to use it was put forward. The challenge has not yet been taken up – make of that what you will!

The next lunch’n’learn we did was a C# in depth one – we had two videos lined up for this with the final choice down to a vote on the day. The team chose a Jon Skeet talk called “Abusing C# More”. As ever, Jon is very interesting and when you twist the language like this you do have to think about the internals in greater depth than you usually do. Very little of practical use in this talk however, it was great to have something a little lighter this time.

Abusing C# More – Jon Skeet from NDC Conferences on Vimeo.

Azure Service Bus lunch’n’learn

This is more for archival purposes really – the talk is quite out of date as it covers native queue usage as HTTP whereas it’s probably easiest just to use a library like MassTransit. It’s also really, really long. However if you skip through the sections to some of the more advanced Service Bus features it could be useful – especially if you’re new to message-based architectures.

Lunch’n’Learn – async/await

We’ve recently started doing more work with the async/await keywords (a side-effect of using MassTransit) and we thought it was a good idea to go through the basics again. Here’s the talk I found which is very easy to follow, full of useful information and well-recorded (if a little dry) – it focuses on usage within but that’s useful for most of us.

Additional bonus video about whether you should always be using an O/RMs (9 minutes, funny):

Productivity lunch’n’learn

Here’s a great Scott Hanselman talk about productivity – he’s been giving it for a while so there are a lot of versions out there, however this is probably a good balance between length / audience interaction and sound quality.

It’s not directly development related but was received really well by the team here.

UI and other network considerations – Embracing the Network lunch’n’learn

This talk is available in various forms across the web and it’s interesting the difference in reaction it received – with the old team at Haymarket we came up with about two pages of suggested changes to our front-end code and other improvements.

At Mountain Warehouse, a lot less interest – but then the team is fairly back-end focused and never really get to play with the UI.

Note: this is a different video of the same talk as the original has vanished.

SmashingConf 2015 Barcelona: Patrick Hamann — Embracing the network from Smashing Magazine on Vimeo.

MassTransit / RabbitMQ lunch’n’learn

Today I ran a lunch’n’learn around MassTransit and event driven architecture. In addition to some demo code, we watched the video below. It covers things quite nicely, not a lot of detail in the demonstration but as it’s MassTransit 2.x (not 3.x) that was OK. Quality is good, speaker is a little drone-y so a bit of snooze-danger if you’ve had too much pizza!

Loosely coupled applications with MassTransit and RabbitMq – Roland Guijt from NDC Conferences on Vimeo.

RESTful API lunch’n’learn

A little while ago we did a RESTful API lunch’n’learn session. These are the videos that we used.

This video from Stormpath covers a lot from basics to good patterns to use – it’s also good quality and as a speaker he’s quite animated so this kept our attention:

For those people who’ve used more SOAP services this video has been good to help compare approaches – however it does seem as if the presenter prefers SOAP (what else would you expect from Oracle?) so you have to apply your own salt:

Other notes

Here’s a quick overview of the properties of the HTTP verbs (this applies to more than just REST APIs!):

GET – Safe, Idempotent
PUT – Idempotent
DELETE – Idempotent
HEAD – Safe, Idempotent
POST – (none of these)

Safe: Makes no change to the server / performs no action. For e.g. reading an entity is a safe, incrementing a counter or sending an e-mail is not.

Idempotent: Doing this multiple times is the same as it doing it just once. For e.g. “a = 1” is idempotent. “a += 1” is not.

Monitoring ViewState size

A short and very dirty script I wrote for TamperMonkey that keeps an eye on the size of your ViewState and alerts you if it gets a bit big. I appreciate this could be a lot better written feel free to take and adapt and improve – although let me know as well please!

Don’t forget to change the @match parameter

// ==UserScript==
// @name         Monitor ViewState size
// @namespace
// @version      0.1
// @description  Monitors ViewState on page and alerts you if it gets big!
// @author       Rob Church
// @require
// @require
// @match        http://**
// ==/UserScript==

/* jshint ignore:start */
var inline_src = (<><![CDATA[
/* jshint ignore:end */
/* jshint esnext: true */

    var allowedViewStateSize = 5000;
    var alerted = false;
    var viewStateSize = document.querySelector('#__VIEWSTATE').value.length;
    if (viewStateSize > allowedViewStateSize) {
       alert('Viewstate is large: ' + viewStateSize);
       alerted = true;

       var viewStateSize = document.querySelector('#__VIEWSTATE').value.length;
       if ((viewStateSize > allowedViewStateSize) && (alerted == false)) {
          alert('Viewstate has *BECOME* large: ' + viewStateSize);
          alerted = true;
    }, 2000);

/* jshint ignore:start */
var c = babel.transform(inline_src);
/* jshint ignore:end */