I bet you can’t go a day without hearing someone rave about AI nowadays. Even if you’re not in the tech field, it’s hard to escape the buzz. ChatGPT and similar generative AI tools are popping up everywhere, have already started to impact people’s daily lives, and it seems like everyone is trying to find ways to use (or abuse) them.

The possibilities have caused significant excitement and unease in people. The big question is: will this technology replace everyone’s jobs and send humanity spiralling into an apocalyptic abyss, or are we on the brink of a golden age?

ChatGPT’s ability to converse like humans, has made a lot of people apprehensive and has made it easy to treat it as potentially sentient. However, consider that the concept of telling machines what to do, and that becoming easier over time with layers of abstraction, is not anything new. Remember the days when working in our industry meant slogging through obscure low-level language syntax and mucking around with memory allocations? Instead, we now have high-level languages like C# that read very close to English, and make programming more accessible. With things like ChatGPT, you’d still be “programming” machines to do what you want, just in a much more accessible way. So it’s all just another step towards easier communication with our future robot overlords machines.

Change can be scary. We humans are intrinsically cautious of and resistant to change (or more specifically, the unknown). But let’s not forget, we’re also the most adaptable species on this little blue rock. We’ve gone through (and created) some massive disruptions and changes in our time.

Consider this: throughout history, we’ve made tools to help us do things faster or to replace manual labour altogether. Sure, some jobs changed or vanished, but new ones emerged, leaving us more time for creative problem-solving and doing less low-value busy work. There are too many examples from history, but I’ll go through a few.… Read more

I received the Impact Mapping book as a gift from my company, Telstra Purple. It’s been in my long reading backlog for a while, but I finally got around to reading it on the weekend and found it a great and easy read while being full of gems. A lot of the concepts resonated with me, especially because I already knew about the concept, but I still picked up a few ideas. Here are the golden nuggets I wrote down as I was reading the book:… Read more

As working from home has become the new normal for a lot of professionals during the pandemic, communication over conference calls has posed more of a challenge. I’m not talking about the funny WFH incidents as people and their families are adapting to the new situation. I’m talking about not being able to leverage non-verbal communication as before, which is commonly believed to be responsible for the majority of our communication’s impact.

With fewer communication opportunities and negligible body language visibility, we’re now relying on the clarity of our words and voice more than ever. Having a decent sound setup is no longer just a nice-to-have for those occasional WFH days – it’s become essential.

Having a decent microphone is a good start, but improving your setup doesn’t necessarily have to cost much. In fact, I recently improved my setup a great deal without spending any money by just removing background noise using free software. Let me take you through how I did it:… Read more

Pull requests and code reviews are one of the most powerful software quality tools we have available in our tool-belt.

Even when flying (han) solo on a project, I tend to create feature branches and PRs and review my own code after a short break; I usually find a few things I can improve when doing that, with the added benefit of being able to switch easily to other work if needed.

In teams, the benefits are many and more significant: extra pair of eyes are always better in spotting improvement opportunities and catching mistakes, they consistently raise the quality of the project in all areas to the best of the team’s knowledge rather than individuals, they reduce the project risk by sharing knowledge and breaking down information silos while upskilling everyone. To a much much lesser degree of importance, they are about guarding the project against YOLO pushes of crap code – that’s more relevant for public, open-source projects; if that’s your main reason for using pull requests and code reviews, that’s a sign of bigger root problems in the team.

However, this post isn’t about those more commonly known benefits; it’s about how code reviews are one of the best places to observe and gauge a team’s health. I recently thought about this as I was reading the excellent book called “The Five Dysfunctions of a Team”, recommended to me by my dear colleague Mehdi Khalili.

In the book, Patrick Lencioni talks about the following five core team dysfunctions which build on top of each other. I’ll go through them and note how they can be observed in PRs and code reviews… Read more

I’m a big proponent of integration and functional tests (or “subcutaneous tests” if there’s a UI). Done efficiently and sparingly, they give you the biggest bang for your buck when it comes to confidence in the overall well-being of the majority of your system.

Dependency injection is ubiquitous these days, and ASP.NET Core MVC’s seamless support for integration testing via the Microsoft.AspNetCore.Mvc.Testing NuGet package has made this kind of testing simple when using dependency injection. However, I found that when dealing with Azure Function Apps, a similar setup is not as effortless as installing a package and using a WebApplicationFactory, especially since Azure Function projects aren’t set up for dependency injection out of the box. Fortunately, after a bit of digging under the hood of Microsoft.AspNetCore.Mvc.Testing and Microsoft.AspNetCore.TestHost, I’ve been able to create a similar testing experience which I’ll go through below… Read more

I often see arbitrary patterns used for versioning packages and assemblies, especially for internal projects, with the only common goal being that the versions are increased with each release. There is rarely a distinction between NuGet package Version, AssemblyVersion, FileVersion and InformationalVersion and they’re commonly all set to the same value, if set at all. That’s not to blame anyone, having all these different ways to set a version is darn confusing.

However, if you plan to release a public NuGet package, or an internal package that could be heavily used, you’ll be making your life, and your users’ lives a lot easier, and avoid creating a “dependency hell”, if you distinguish between the above versions and follow a meaningful versioning strategy like Semantic Versioning.

If you haven’t heard about Semantic Versioning, here’s the TL;DR… Read more

.NET Programmers have traditionally shied away from writing asynchronous code, and mostly for good reason. Writing asynchronous code used to be arduous work and the result was difficult to reason about, debug and maintain. That became exacerbated when you threw concurrency into the mix – parallel or asynchronous – as that’s harder to consciously follow for our brains which are optimised/trained for non-concurrent and sequential logic.

The compiler magic of async/await since C# 5.0 and the Task-based Asynchronous Pattern has immensely improved that experience, mainly by abstracting asynchronous code to read like synchronous code. In fact it’s been such a big hit that it’s spread and been adopted by many other popular languages such as JavaScript, Dart, Python, Scala and C++.

This has resulted in a trend of more and more asynchronous code popping up in our code-bases. That’s mostly a good thing, because leveraging asynchrony in the right place can lead to significant performance and scalability improvements. However, with all great magic, comes great misconception. I’ll go over some of the most common ones below which I encounter often… Read more

Integrating systems over a good messaging infrastructure has many benefits if done right. Some of these are system/network decoupling and platform agnosticism, independent scalability, high reliability, spike protection, a central place to keep an eye on your integrations and more depending on your situation.

Many of these benefits are vast topics on their own. But the point of this article is to go over some of the pitfalls when implementing large-scale integrations over a messaging infrastructure and guidelines for avoiding them.

These are based on my learning from a recent project which involved improving a client’s existing integration between 5+ large systems. While the messaging infrastructure in use was the Azure Service Bus, I believe most of these points apply to all other message-based integrations and service buses… Read more

Update: starting from EF Core 3.0-preview 4, this damaging default behavior has been greatly limited, although not completely turned off.

Recently when going through our shiny new ASP.NET Core application’s logs, I spotted a few entries like this:

The LINQ expression ‘foo’ could not be translated and will be evaluated locally.

Odd.

I dug around in the code and found the responsible queries. Some of them were quite complex with many joins and groupings, while some of the other ones were quite simple… Read more

Visual Studio Code Snippets are awesome productivity enhancers; I can only imagine how many millions of keystrokes I’ve saved over the years by making a habit out of using them.

Although a lot of common code you use daily might not be available out of the box, adding them yourself is very simple… Read more

Making a singleton application, i.e., preventing users from opening multiple instances of your app, can be easily implemented using a Mutex.

A Mutex is similar to a C# lock, except it can work across multiple processes, i.e. it is a computer-wide lock. Its name comes from the fact that it is useful in coordinating mutually exclusive access to a shared resource… Read more

I rarely use tools that generate code, however, one that has become a fixed asset of my programming toolbox is Visual Studio’s class designer. It’s a great productivity tool that helps you quickly visualize and understand the class structure of projects, classes and class members. It’s also great for presentation of code-base that does not come with a UI, e.g. a Class Library… Read more

When you git commit, Git automatically uses your system’s local timezone by default, so for example if you’re collaborating on a project from Brisbane (UTC +10) and do a commit, your commit will look like this:

commit c00c61e48a5s69db5ee4976h825b521ha5bx9f5d
Author: Your Name <your@email.com>
Date:   Sun Sep 28 11:00:00 2014 +1000 # <-- your local time and timezone offset

Commit message here

If you find it rather unnecessary to include your local timezone in your commits, and would like to commit in UTC time for example, you have two options… Read more