A new course: Day to day software design for .Net Programmers

April 2, 2015 at 5:36 pm Leave a comment

Just over a year ago, I unveiled our Parallel and Async C# 5 course. It was immediately popular, and I’ve been enjoying teaching it at a number of locations. Today, I’m happy to announce another addition to our .Net offerings – and it’s something a little different to any of our courses so far.

Our existing .Net courses have focused on the C# language, a particular theme (such as TDD or parallelism/asynchorny), or a particular framework (such ASP.NET MVC or WPF). However, there is much more to being an effective developer than knowing tools, frameworks, and languages.

In our day to day development, we have to make all kinds of choices and trade-offs. While the decisions we make may each be fairly small, together they have a large impact on the quality of the software we produce. Large systems stay maintainable mostly through boundaries and abstractions being respected – but this respect is only possible when we can trust what lies beneath an abstraction. And that trust is gained through the code behind an abstraction making all of the little choices correctly, delivering consistent and predictable behavior.

Making good design choices is challenging. Let’s start at the bottom of the stack and work our way up to see some of the reasons why.

  • Modern hardware is complicated, and has non-obvious performance behavior both in terms of instruction execution and memory access
  • The CLR is not a simple, naive executor of bytecode. For one, the JIT compiler does some potentially surprising things. But more importantly, garbage collection is neither free nor magical, and there are ways it can bite you – not only in hot-path algorithmic code, but also in typical server applications.
  • Everyone knows List<T> – but is it always the best choice? When is LinkedList<T>, Queue<T>, Stack<T>, BitArray, or even just a plain old Array, a better choice? How do we use dictionaries well? What are trees and graphs good for? What do those O(…) things in the MSDN actually mean? There’s plenty to know about picking good data structures.
  • C# supports object-oriented programming. But much OO code written in C# sucks: it’s full of Manager or Service classes, the only pretense at encapsulation is the use of properties rather than fields, and attempts to test it mostly seem to result in wasting a lot of time updating tests on every refactor. This is not how OO should be, but to do better needs us to re-consider what OO even is. Spoiler: it’s not really about objects!
  • We hear plenty about “mutable” and “immutable” – but deciding between them can be tricky. Heck, how do we even apply the ideas of immutable data when we know things in the real world change?
  • We often hear that “extensible” or “composable” designs are desirable – but rarely discuss what the two words might mean. When do we pick inheritance, interface implementation, or take a Linq-esque monoid-y approach?
  • Time comes into a lot of business domains, but time is gnarly. Humans are wonderfully imprecise about dates and times in almost all their day to day interactions on the subject, relying on context to resolve the ambiguities. Computers lack that context – and sadly the .Net DateTime classes don’t do a great job of making that clear.

Our new Day to day design for .Net programmers course takes on all of these issues – and more. It aims to fill in a bunch of common knowledge gaps and shed some light on a number of areas that are typically under-discussed – thereby helping developers produce better-considered software.

As for prerequisites for this course, we believe anyone who has handled our Intermediate C# course (or has equivalent skills) will be in a good place to take it. Mostly, our requirement is that participants have a good working knowledge of modern C# (that is, including generics, lambdas, and Linq) – since the point of the course is not about learning the C# language, but rather about designing good programs that take C# and the CLR into account. This choice of prerequisite also indicates that we don’t consider this a hugely advanced course; senior developers with a good computer science background and a bunch of years experience may only find so much new. As always, please take the time to read the topic outline, to decide if the course is right for you.

I’ll be sharing the teaching of this course with other Edumenters, who have contributed in various ways to its development. We look forward to getting this new course “on the road!”

Here’s the abstract and how to book the course; as usual, there will be classroom sessions or you can have it at your company.



Entry filed under: Courses. Tags: , .

Är servicedesken död? We want you!

Leave a Reply

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

WordPress.com Logo

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

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Trackback this post  |  Subscribe to the comments via RSS Feed

%d bloggers like this: