.NET Development

The second in a series of posts talking about how and why we migrated an application from Azure Functions to Azure Container Apps

C# has gradually been adding support for discards. This article explores how this evolution has led to some surprises.

The first in a series of posts talking about how and why we migrated an application from Azure Functions to Azure Container Apps

There are three lifetimes available with the Microsoft Dependency Injection container: transient, singleton, and scoped. In this post, we explain their different behaviours and the importance of being aware of the lifetimes of the dependencies in our applications.

Have the recent changes to Azure CLI on Windows broken your dev inner loop when working with containerised applications that need access to Azure resources? If so, this post provides a workaround that will unblock you without having to be stuck on an old version of the Azure CLI.

If you're interested in the Distributed Application Runtime (Dapr) and how it can simplify migrating existing workloads to use cloud platform services, then this series might be for you. In this post, we continue modifying the excellent Dapr Traffic Control sample application by swapping the MQTT-based messaging with Azure Storage Queues. We will also look at how you can use the Dapr programming model as an alternative to cloud-provider SDKs.

The stack and heap are central components of memory management in C# programs. This post aims to introduce the topic, with a number of worked examples.

In this post, we will be showing how to implement dependency injection in an ASP.NET Core application.

It's possible to get into a tricky situation when combining asynchronous methods that return Task objects with multicast delegates in C#. In this post Liam explains how that situation arises.

Debugging allows us to troubleshoot problems in our applications by stepping through our code line by line, and stepping into methods when necessary. But there might be instances where the process is not so straightforward. Debugging NuGet packages is one of them.

If you're interested in the Distributed Application Runtime (Dapr) and how it can simplify migrating existing workloads to use cloud platform services, then this series might be for you. In this post, we continue modifying the excellent Dapr Traffic Control sample application by adding Azure Key Vault integration for its secrets management.

Lambda expressions are a syntactically light way of defining functions, but they can seem cryptic when first coming across them. In this post, we look at their syntax in C# and some examples.

In this blog post, we explain how to implement authentication and authorisation capabilities to an ASP.NET Core web application by exploring different concepts, such as Identity, Razor class libraries, scaffolding, and partial views.

In this post, we explore tag helpers, used in web applications using ASP.NET Core. We look at some examples of tag helpers and their uses, and learn how to create custom tag helpers.

This blog post explores how pattern matching has evolved over each version of the C# language and how to use pattern matching with is expressions, switch statements and switch expressions

C# 11.0 has a new syntax, !!, which makes it easier to detect and reject null arguments. It is simple, but misunderstood. This post explains what it really does, and how it has been misinterpreted.

C# 10.0 lets us annotate the nullability aspects of generic code more naturally than older versions. Some places where the AllowNull attribute was once required can now just use the obvious nullability syntax.

In this post, we explore the Configure method in the Startup class in a ASP.NET Core web application. Inside of the configure method we find the middleware pipeline, responsible for processing HTTP messages.

.NET 6.0 makes it easier to take full advantage of code analyzers that can help you improve the quality of your code.

Model Binding automates the process by which web applications extract data from HTTP requests and converts it to .NET types, making it easier to pass information into an input model. In this post, we will see how and why model binding is used.

This post explains how to control the flow of execution in C# by using if and switch statements and looping with for, foreach, while and do.

Containers and Docker offer a different approach to development and deployment of applications. This post provides an introduction to containerisation and Docker, and provides examples of creating containerised applications with Docker.

When we tested endjin's AIS.NET library on .NET 6.0, we were delighted to see substantial performance gains, with no extra work required.

If you're interested in the Distributed Application Runtime (Dapr) and how it can simplify migrating existing workloads to use cloud platform services, then this series might be for you. In this post, taking the excellent Dapr Traffic Control sample application as our starting point, we look at enabling PaaS Pub-Sub using Azure Service Bus.

If you're interested in the Distributed Application Runtime (Dapr) and how it can simplify migrating existing workloads to use cloud platform services, then this series might be for you. Taking the excellent Dapr Traffic Control sample application as our starting point, we will iteratively migrate components to use Azure cloud platform services.

C# 10.0's support for CallerArgumentExpression and some new helpers in .NET 6.0 make throwing argument exceptions more succinct and less error prone.

In this post, Nehemiah reflects on his first month at endjin as an apprentice engineer.

C# 10's new implicit global imports can make your code more communicative. This article shows how the magic works, and how you can control the feature.

Learn how code generation can build on System.Text.Json and JSON Schema to create a great experience for C# developers.

The first in a series of posts talking about how to best work with configuration in Azure Functions

A rundown of how to trigger an Azure Synapse pipeline run from C# code.

Get started with Mattermost on Azure using the Mattermost on AKS quickstart from the Azure CNAB Quickstart Library.

This blog is part of a series around design patterns. This post focuses on the proxy pattern. The proxy pattern is used to restrict and control access to underlying objects. It is useful in communicating with remote servers, or in adding extra functionality on object access.

Automating the updating of Power BI data source credentials is a common requirement in the application lifecycle management of a Power BI solution. However, on-premises data sources throw an extra spanner in the works: you must encrypt your credentials using the RSA-OAEP encryption algorithm before sending off the request to update the data source. There is currently no PowerShell module that encapsulates this logic into a set of handy cmdlets, so you must either implement the algorithm's logic yourself, or you can use the helper classes in the existing .NET SDK to do all the heavy lifting for you. This blog shows how to do the latter.

Sometimes the logic for the bit of work you're doing in PowerShell won't be packaged into a handy PowerShell module with cmdlets to perform the operations you need to perform. But what if there is a .NET package listed on NuGet that does contain the assemblies you need for your work? How can we import that into PowerShell and make use of its classes and methods? This blog explains how to do just that, avoiding current pitfalls in PowerShell's implementation of the NuGet package provider.

C# 9 makes welcome additions to the language's increasingly powerful pattern matching capabilities. However, with great power comes a temptation to make a great big mess. In this post, Ian Griffiths urges us not to get carried away.

CodeOps enables you to layer standards, automation, and governance to your source control repositories, decreasing manual effort and increasing productivity.

This blog is part of a series around design patterns. This post focuses on the facade pattern. The facade pattern provides an interface into a complex system, in order to simplify access to the functionality.

This blog is part of a series around design patterns. This post focuses on the adapter pattern. The adapter pattern is used to enable you to use the functionality defined by a class which is not compatible with the interfaces/architecture of your solution.

Enabling C# 8's nullable references feature often produces a lot of warnings. Avoid the temptation to make some go away by initializing properties to empty strings.

This blog is part of a series around design patterns. This post focuses on the decorator pattern. The decorator pattern is used to dynamically add additional properties to objects in order to extend functionality.

GitOps (sometimes known as 'operations by pull request') is most often discussed as being an approach for managing your Kubernetes platform, but in this post I will make the case for how it can benefit a much wider audience.

Prepare for using C# 8.0 nullable references by not misusing the 'as' operator.

Often when building software we need to outsource part of the solution to a third party. Common examples include authentication, payment, and email, but there are many others. When first designing a solution the decision around which provider to use can be difficult to tackle. At endjin we have developed a system for answering the question "which provider should I use?".

Creating meta/virtual NuGet packages to encapsulate frequently used collections of dependencies can be an effective way to both simplify their consumption as well as streamline the process of integrating and testing new versions using tools like Dependabot.

Tracking down unexpected allocations in a high-performance .NET parsing library.

Have you tried using the new System.CommandLine packages? This blog shows you how to build up a command line tool quickly and easily, using dependency injection for the initialisation.

C# 8's nullable references feature can clash with common serialization techniques. This article shows how to deal with that.

Azure AD B2C is easy to integrate and configure for simple sign-in / sign-up authentication. But there's a step change in complexity as soon as you want to do something outside of the built-in user flows. An "invite user" flow is one such example, but it's also a fairly common requirement in any business or team orientated SaaS application, which makes AAD B2C as less attractive choice. This post describes an alternative approach for this authentication feature that avoids the need for AAD B2C custom policies, allowing you to keep authentication as simple as possible.

The DoesNotReturn and DoesNotReturnIf attributes have been around for a long time in C#, but they take on additional significance when using C# 8 nullable references.

This blog gives an example of a pattern used for asynchronous initialisation. This pattern allows you to construct readonly objects. It also allows you to use the new nullable references features to ensure your classes are always fully instantiated.

Ian Griffiths is talking about the Reactive Extensions for .NET at dotnetsheff. Learn the ideas behind Rx, and see it applied in an IoT applicable to upload clinical monitoring data to the cloud.

See how to use C# 8.0 nullable references even when targetting older versions of .NET that don't officially support it.

Do you need to encrypt a piece of data in your application? Do you want Azure Key Vault to secure the key? Well, using C# along with a couple of libraries from the Azure SDK, it couldn't be easier to get up and running. This blog explains how to do just that.

C# 8.0 nullable references enable us to annotate our code with information that lets the compiler discover possible null-related bugs. The DisallowNull attribute lets us get more expressive with properties and generics.

The NotNullWhen MaybeNullWhen, and NotNullIfNotNull attributes enable C#8 provide better nullability warnings, by helping it infer information about a method output based on other inputs.

This blog post explains how you can automatically open a web browser in either private browsing mode or with a custom user profile when debugging web applications from Visual Studio.

The MaybeNull attribute enables C#8's nullable references feature to provide more useful warnings, by helping it infer information about a method output.

The NotNull attribute enables C#8's nullable references feature to provide more useful warnings, by helping it infer information about a method argument.

Have you ever needed an automated process to use alternative credentials for a subset of tasks? This post will demonstrate a technique that allows you setup multiple, concurrent authenticated sessions when using the azure-cli and switch freely between them.

Have you or are you about to invest in Azure Databricks? If so, the new Spark offering in Azure Synapse Analytics is likely to have grabbed your attention and rightly so. Why is Microsoft putting yet another Spark offering on the table and what does it mean for you?

C# 8.0 nullable references enable us to annotate our code with information that lets the compiler discover possible null-related bugs. The AllowNull attribute lets us get more expressive with properties and generics.

C# 8.0 nullable references enable us to annotate our code with information that lets the compiler discover possible null-related bugs.

Whilst "read/write XMLA endpoint" might seem like a technical mouthful, its addition to Power BI is a significant milestone in the strategy of bringing Power BI and Analysis Services closer together. As well as closing the gap between IT-managed workloads and self-service BI, it presents a number of new opportunities for Power BI developers in terms of tooling, process and integrations. This post highlights some of the key advantages of this new capability and what they mean for the Power BI developer.

Improve the already-great Windows Terminal experience by following these tips for customizing the application to work best for you.

C# 8.0's nullable references feature dramatically changes a fundamental aspect of the language. In this post, Ian explains how to you can soften the impact by enabling gradually across your projects.

Despite being inherently difficult to test, the need to validate data modelling, business rules and security boundaries in Power BI reports is important, as well as the need for ensuring that quality doesn't regress over time as the insights evolve. This post explains that, by connecting to the underlying tabular model, it is possible to execute scenario-based specifications to add quality gates and build confidence in Power BI reports, just as any other software project.

C# 8.0 has two related but distinct notions of nullability. In this article, Ian explains why inferred nullness is a vitally important part of the language's new Nullable References feature.

Whilst testing Power BI Dataflows isn't something that many people think about, it's critical that business rules and associated data preparation steps are validated to ensure the right insights are available to the right people across the organisation. Data insights are useless, even dangerous, if they can't be trusted, so despite the lack of "official support" or recommended approaches from Microsoft, endjin treat Power BI solutions just as any other software project with respect to testing - building automated quality gates into the end to end development process. This post outlines an approach that endjin has used to test Power BI Dataflows to add quality gates and build confidence in large and complex Power BI solutions.

C# 8.0 nullable references offer benefits besides the obvious win of detecting null-related coding errors. This new language feature can also improve the expressiveness of your code.

Azure Analysis Services provides an enterprise-grade analytical platform with massive scale and flexibility. But, as one of the more expensive services in the Azure platform, consideration should be given to cost management, especially in multi-environment ALM scenarios. This post explains how to massively reduce running costs through automation using Powershell and orchestration tools like Azure DevOps.

At endjin, our approach focuses on using scientific experimental method to support the creation of fully proved and tested decision making, and the use of scientific research to support our work. This post runs through how we applied that process to creation a pipeline to detect vessel proximity.This is an example which is based around the project we recently worked on with OceanMind. In this project we helped them to build a #serverless architecture which could detect vessel proximity in close to real time. The vessel proximity events we detected were then fed into machine learning algorithms in order to detect illegal fishing!Carmel also runs through some of the actual calculations we used to detect proximity, how we used #data projections to efficiently process large quantitities of incoming data, and the use of #durablefunctions to orchestrate the processing.

During our projects at endjin, we often find ourselves evangelising Behaviour Driven Development, and specifically SpecFlow. In this post we look at a technique for defining complex test data objects in your Gherkin feature files, which we've also made available via the endjin-sponsored Corvus.NET project.

C# 8.0 has an ambitious new feature, called nullable references. In this post, Ian explains why this makes a fundamental change to the default assumptions about nullability.

See how to manage consistent default configuration across all your .NET projects by using NuGet build assets.

If you use Azure Functions on a regular basis, you'll likely have grappled with the challenge of testing them. Even now, several years after their introduction, the testing story for Functions is not hugely well defined. In the final post in this series, we show how to ensure specs written using Corvus.Testing can run as part of your build pipeline.

If you use Azure Functions on a regular basis, you'll likely have grappled with the challenge of testing them. Even now, several years after their introduction, the testing story for Functions is not hugely well defined. In the fourth of this series of posts, we look at how configuration can be supplied from your tests to the functions apps being tested.

If you use Azure Functions on a regular basis, you'll likely have grappled with the challenge of testing them. Even now, several years after their introduction, the testing story for Functions is not hugely well defined. In the third of a series of posts, we look at using classes in the Corvus.Testing library to run functions apps via scenario and feature hooks.

If you use Azure Functions on a regular basis, you'll likely have grappled with the challenge of testing them. Even now, several years after their introduction, the testing story for Functions is not hugely well defined. In the second of a series of posts, we look at using step bindings provided by the Corvus.Testing library to run functions apps as part of your SpecFlow scenarios.

If you use Azure Functions on a regular basis, you'll likely have grappled with the challenge of testing them. Even now, several years after their introduction, the testing story for Functions is not hugely well defined. In the first of a series of posts, we look at some different approaches to testing your functions apps, and introduce the Corvus.Testing library.

C# 7.2 introduce ref structs, a new kind of type (Span<T> is a ref struct) designed to support certain high performance scenarios. There are constraints around their use, and when writing unit tests for our Ais.Net parser, this caused some challenges. This blog describes the technique we used to work around the constraints.

The application of scientific experimental process to software development leads to the development of fully-validated solutions. This approach provides you with confidence in designs and means that you can quickly identify ideas which are not worth pursuing. At endjin we use the ideas of hypotheses and experimentation when designing any solution and this gives us full confidence in the designs we produce. In this post we outline the steps and advantages of using this approach.

As part of my series on guidance for CTOs, I discuss using the Office of the CTO (OCTO) approach to management, its strengths and limitations.

Integrating Azure Analysis Services into custom applications doesn't just mean read-only data querying. But if your application changes the underlying model, it will need to be re-processed before the changes take effect. This post describes how to use the REST API for Azure Analysis Services inside a custom .NET application to perform asynchronous model refreshes, meaning your applications can reliably and efficiently deal with model updates.

As part of our work with OceanMind, endjin wrote a high performance .NET AIS parser. AIS (Automatic Identification System) is how commercial ships report location information. This blog describes the parser, and the performance techniques it uses.

There are hidden pitfalls with dependency injection, particularly when managing the lifetime of scoped components. What is safe? And are there other approaches we can take to managing scoped object lifetimes?

Being able to construct DAX queries dynamically in C# means the possibilities are endless in terms of integrating Azure Analysis Services queries into your custom applications, and with the code samples in this post, you have everything you need to get started.

Ian spent a big chunk of last year writing an update to his book, Programming C# 8.0. Books continue to be Ian's preferred source of learning because nothing else offers the combination of depth, breadth, and coherence. His goal with Programming C# 8.0 (and its predecessors) was very clear: to write the book that he would want to read if he were learning C# today. It is Ian's attempt to distil around 18 years of experience with C# (part of almost 30 years of work as a programmer) into a coherent, complete description of what you'll need to know to be productive today in C#.

Porter is a tool based on the CNAB (Cloud Native Application Bundle) spec. It can be used for building, managing, and installing application bundles. This guide will walk you through how to get set up with Porter on Windows.

In this post, we describe the steps needed to enable Windows Subsystem for Linux (WSL) 2 on Windows 10, and how you can use the WSL 2 features with Docker for Windows.

The Azure CNAB Quickstarts Library helps you get up and running with CNAB and Porter. We've built quickstarts covering solutions like WordPress, Ghost, Mattermost, and data platforms like Apache Airflow, SQL Server AlwaysOn clusters and Kubernetes features like an nginx ingress controller and an Azure AD enabled OAuth2 Proxy. We've condensed all our learnings from the past 9 months of working on the project and turned them into a 10 minute video which explains all the key concepts. We hope this video helps accelerate your own CNAB & Porter epiphanies!

In partnership with Microsoft, we have released Azure CNAB Quickstarts Library on GitHub. CNAB (Cloud-Native Application Bundle) is a new specification designed for facilitating the packaging, installation, upgrading and uninstallation of cloud-native solutions in the cloud, on-premise or on the edge. We've created a number of quickstarts covering Apache Airflow, Azure Kubernetes Service, Ghost, Kubeflow, SQL Server Always On and Wordpress to help demonstrate the power of CNAB and Porter.

Integrating Azure Analysis Services into custom applications means more than just querying the data. By surfacing the metadata in your models, you can build dynamic and customisable UIs and APIs, tailored to the needs of the client application. This post explains how easy it is to query model metadata from .NET, so you can create deeper integrations between your data insights and your custom applications.

One of the first steps in integrating Azure Analysis Services into your applications is creating and opening a connection to the server - just like any other database technology. This post explains the ins and outs of creating Azure Analysis Services connections, including code samples for each of the key scenarios.

Ed attended NDC London 2020, along with many of his endjin colleagues. In this post he summarises and reflects upon his favourite sessions of the conference including; "OWASP Top Ten proactive controls" by Jim Manico, "There's an Impostor in this room!" by Angharad Edwards, "How to code music?" by Laura Silvanavičiūtė, "ML and the IoT: Living on the Edge" by Brandon Satrom, "Common API Security Pitfalls" by Philippe De Ryck, and "Combatting illegal fishing with Machine Learning and Azure - for less than £10 / month" by Jess Panni & Carmel Eve.

In this post, Ian describes some of the highlights from the NDC London conference

Along with several of my endjin colleagues, I attended NDC London in January this year - here's a run through of the sessions I attended on Day 3 and my thoughts. This final day was a mixed bag, taking in talks on drumming and AKKA.net, as well as something a bit more close to home - a session from endjin's own Jess Panni and Carmel Eve on our recent project for OceanMind.

Along with several of my endjin colleagues, I attended NDC London in January this year - here's a run through of the sessions I attended on Day 2 and my thoughts. This day was UI heavy, with sessions on Vuejs and UI testing, but I also learned more about GraphQL and writing high performance C# code.

A retrospective of my first day at NDC London 2020, taking in sessions on AI and Machine Learning, Capability Mapping, Micro Frontends, Diagnostics and Blazor.

With a variety of integration support through client SDKs, PowerShell cmdlets and REST APIs, it can be hard to know where to start with integrating Azure Analysis Services into your custom applications. This posts walks through the options, and lays out a simple guide to choosing the right framework.

The 'positional patterns' added in C# 8 support types with custom desconstructors. However, the way this works might always be quite what you would expect. This article shows a surprising behaviour, and explains how it arises.

The addition of ref struct types, most notably Span<T>, opened C# to a range of high performance scenarios that were impractical to tackle with earlier versions of the language. However, they introduce some challenges. For example, they do not mix very well with async methods. This article shows some techniques for mitigating this.

GitHub Actions is GitHub's new CI/CD platform. It is comparable with Azure Pipelines, which forms part of the Azure DevOps suite. In this post, Mike Larah looks at the similarities and differences in the high-level concepts and terminology between the two platforms.

While on first inspection Azure Function look like a good candidate for long running operations as they can run for 10 minutes on a Consumption plan, HTTP Triggers only run for 230 seconds because of a limitation with the Azure Load Balancer. In this blog post Jess Panni demonstrates how Durable Functions can be used instead.

Remote working allows us to work from anywhere we want. This brings a huge amount of flexibility in freedom, however we do need the help of a working laptop! When Carmel's laptop gave in just before a trip, she used Azure DevTestLabs to allow her to continue to work using a 10 year old Mac that probably couldn't wouldn't have been up to the task alone...

In this post, Mike Larah explains how to enable SSH on the Pi, how to access the Pi via SSH using a Windows 10 development machine, and how to enable passwordless SSH access to the Pi.

We worked on a project recently which required us to build a highly performant system for processing vast quantities of messages in real time. We had made the decision to run this processing using Azure Functions with C#. This post runs through some of the techniques we used for writing highly performant, low allocation code, including data streaming, list preallocation and the relatively new C# feature: Span&lt;T&gt;.

For one of my first experiments with the Raspberry Pi 4, I decided to get an Azure Function running in a Docker container. This post gives a step-by-step guide on how to do it, as well as providing code you can use a starting point for your own experiments.

In this post we show a smooth entry animation for D3.js donut (or pie) charts, using a combination of a sweep and a zoom to give a corkscrew-like effect.

This blog is part of a series around design patterns. This post focuses on the composite pattern. The composite pattern is often used in situations where you want to me able to treat groups and individuals in the same way during processing.

This is the second blog in a series around design patterns. This post focuses on the builder pattern. The builder pattern is used when there is complex set up involved in creating an object. Like the other creational patterns, it also separates out the construction of an object from the object's use.

Whilst some of the Azure Active Directory PowerShell for Graph module (AzureAD) functionality has been rolled into the new Azure PowerShell Az module, it's not currently (and might never be) a replacement for the full power of what you can achieve with AzureAD. So, there's every chance you'll find yourself needing to use both side-by-side. This post explains how to do that using the new cross-platform PowerShell Core.

This is the first blog in a series about design patterns. This blog focuses on the differences between the factory method and abstract factory patterns. The factory method is a method which takes the creation of objects and moves it out of the main body of the code. An abstract factory is similar to the factory method, but instead of a method it is an object in its own right.

A Power BI based solution typically consists of a variety of technologies - for example Azure data platform services containing source data. As such, automation of Power BI resources needs to be considered as part of a wider DevOps strategy. This post describes the specific steps needed in order to fully automate the creation and security of Power BI workspaces using Powershell and Azure DevOps pipelines.

Software architecture and Agile project planning are often seen to be at odds. However, here at endjin we think that the way in which they intersect solves a lot of the common issues surrounding architecture. The key to successful architecture is constantly keeping the drivers in mind and having a tight communication loop as the architecture is implemented. These concepts are ones which are key to agile project management, and the combination of these two disciplines can be extremely powerful and successful when applied correctly.

At endjin we have a high quality bar when it comes to our code. As part of this we carry out regular code reviews. One of the tools we have used for these code reviews is NDepend. This is the second in a blog series written as we carried out that process. This post focuses on the insight you can quickly gain just by glancing at the NDepend UI.

This blog post details how we used Azure Policy to enforce Azure resources were tagged with appropiate tags and ensured tags were inherited from parent resource groups where possible.

At endjin we have a high quality bar when it comes to our code. As part of this we carry out regular code reviews. One of the tools we have used for these code reviews is NDepend. This is the first in a blog series written as we carried out that process. This post runs through the different metrics used by NDepend, and the reasons that each of these can be an indication of code quality.

In this, the final article in a series on the potentially deceptive nature of some new features in C# 8, Ian Griffiths shows how using var can sometimes result in better compile-time type checking than using an explicit type. He reflects on the evolution of C#, and what we can learn from this.

C# v8.0 introduces various new patterns. In this article, part of a series on how the evolution of the language has added complexity, Ian Griffiths shows how the strong resemblance between the new Positional Patterns and Deconstruction can be misleading.

In this post Carmel runs through some of the main principles behind agile estimation and planning. At endjin we use a lot of these techniques in our projects and this is a great post which highlights the reasons behind some of what we do. The key motivation behind good estimation is to be useful for project planning. There is a huge amount of inherent uncertainty surrounding estimates, especially early in the project. So, we shift our aim from 100% precise, or "true", estimates, and towards providing estimates which are useful and accurate. Carmel also runs through the steps in an agile delivery and release process. Definitely worth the read if you have an interest in agile and/or project management!

Visual Studio 2019 saw the arrival of C# v8.0. This article shows the first of a series of examples of how friction can arise when integrating new features into a mature language: the relatively late addition of 'discards' causes some surprises.

Visual Studio 2019 saw the arrival of C# v8.0. A programming language cannot evolve for 20 years without developing a few quirks. Ian Griffiths writes about a surprising aspect of the new pattern matching features, and what this reveals about how the language has changed.

Sometimes it's good to go back to the basics... This is a quick post that runs through binary and hexadecimal numbers, and how those relate to our every day computing!

This is the final blog in a series which delves into how the Rx operators work under the covers. This series aims to provide a greater understanding of Rx and its operators. This post focuses on the JOIN operator.

This is the fourth blog in a series which delves into how the Rx operators work under the covers. This series aims to provide a greater understanding of Rx and its operators. This post focuses on the WINDOW operator.

Using PowerShell and the VM Custom Script Extension to download and execute scripts on existing Azure VMs

This is the third blog in a series which delves into how the Rx operators work under the covers. This series aims to provide a greater understanding of Rx and its operators. This post focuses on the GROUP operator.

This is the second blog in a series which delves into how the Rx operators work under the covers. This series aims to provide a greater understanding of Rx and its operators. This post focuses on the AGGREGATE operator.

Two of the main use-cases for explicit interface implementation are: 1. to hide members of the interface in a class which inherits from that interface, and 2. to work around the scenario when a class is inheriting from two interfaces which share a member of the same name. Take a look at this blog to go into more depth about each of those scenarios.

This is the first blog in a series which delves into how the Rx operators work under the covers. This series aims to provide a greater understanding of Rx and its operators. This post focuses on the WHERE operator.

A good test suite should validate behaviour across your code base, testing as many edge cases as reasonably possible. A common "edge case", is passing a null value when a value isn't expected to be null. In Specflow, all values used in scenario examples are treated as strings, so it isn't possible (by default) to pass in a null value. However, using "Step Argument Transformations", we can achieve the desired behaviour. Read this blog to learn how this can be implemented.

At endjin we've done quite a lot of work around reactive data processing. This post is a great introduction to the main concepts in reactive programming. It runs through the main classes in Rx.NET and provides an easy-to-follow explanation of this powerful (and somewhat complex) area of .NET.

Combining deferred execution with asynchronous operations can cause subtle problems. This post shows how to ensure correct operation when these idioms combine.

This is a post about the importance of reducing your dependencies as much as possible when designing solutions.If as much as possible is under your own control, there is far less room for synchronization errors and update conflicts.

Garbage collection is the process in .NET of cleaning up unused memory. Here is a great post which explains how it works under the covers. If you have ever wanted to get an understanding of exactly what is going on behind the scenes when you write C# code, then this is the post for you!

We have lots of experience working with Azure Cosmos DB, and we're sharing some of our knowledge at Microsoft's Future Decoded event.

Structured apprenticeships provide a great way to build skills whilst getting real-life experience. Endjin's apprenticeship scheme has been refined over years, with an optimal mixture of training, project work, and exposure to commercial processes - a scheme which is designed to build strong foundations for a well-rounded Software Engineering consultant. This post explains the transition from university to an apprenticeship at endjin, including the types of work an apprentice could end up doing, and some examples of real-life learnings from a real-life apprentice.

The evolution of .NET is a complex one. We've put together a deck to help you understand what you should choose to use when.

We've just released an updated version of our Azure Technology Selector poster - helping you to choose the right Azure service, based on your use-case.

We ran a two day hackathon with Watchfinder and Microsoft to build a conversational experience to automate the 'sell your watch experience'.

Alice reflects on her final year and an apprentice, what she's learned over the past three years, and the new skills and capabilities she's developed.

JavaScript is one of the most popular programming languages, but is it past its sell by date?

One very useful but little used pattern when working with Resource Manager templates, is the ability to use parameters to optionally deploy resources, constrain certain resource configurations based on other user defined parameters, or to toggle parameters based on other values. This blog post explores some of these options.

Read about how we set up automated backups of our office security camera footage and used Power Automate to alert us if anything went wrong

A career in software engineering doesn't need to start with a Computer Science degree. The underlying traits of problem solving, a willingness to learn and the ability to collaborate well can be built in any field. Internships provide a great way to get your foot-in-the-door in the professional world, and arm you with some real-life experience for future endeavours. This post describes an internship at endjin, including the type of work you could be asked to do and what you could learn.

Creating a package to deploy a web project from the command line (for deployment into Azure) is not as easy as it should be. In this post we cover the whole process.

This post shows how to add a Power BI Embedded report to an ASP.NET Core application.

During her two month internship we tried to expose her to as many different aspects of endjin as possible; from New Proposition Development, marketing, partner & business development activities, as well as our software engineering processes and the Microsoft Azure ecosystem.

Did you know that you can fully automate the bootstrapping process of setting up an Azure DevOps enviornment? This post shows you how.

Learn how to combine the power of Azure Resource Manager and Octopus Deploy for a frictionless Azure DevOps experience.

Azure Machine Learning Studio is a fantastic service for experimentation, but you can also easily productionize your machine learning models. In this post we show how to create an Azure ML Studio web service and test it using Postman.

In this post, Mike Larah reflects on his experiences going through the endjin three-year apprenticeship scheme

We've improved our approach for saving money by turning off our virtual machines outside of office hours. This post explored how to do it using graphical runbooks.

Mike Larah shares his tips for how to best customize ConEmu to improve your terminal experience for Windows Command Prompy and PowerShell

We recently upgraded our TeamCity based CI/CD environment, but we had to make some adjustments to fix failing tests.

Learn how to authenticate against Azure Resource Manager using PowerShell, for fully automated deployments.

Microsoft have added SHA256 support to Signed XML, and Endjin.Licensing has been updating to take advantage of this breaking change.

We've built and open-sourced a Visual Studio Extension that provides basic support for discovering and running CucumberJS tests with Node.JS, in the Visual Studio Test Environment.

In this post, Mike Larah discusses how to ensure your C# collections are thread-safe, only run-once, and are lazy-loaded.

Consumption based pricing is a one of the USPs of Cloud PaaS services, but the default settings aren't necessarily optimised for cost. Significant savings can be made from understanding your workload.

This is a quick guide to setting up cucumber JS in Visual Studio with grunt.

Azure Resource Manager and PowerShell Desired State Configuration are powerful tools for provisioning and then configuring your virutal machines in Azure. This post delves into the details.

Git has powerful extensibility points, which you can harness to automate your dev inner loop. In this post we examine how to use Git Hooks to reduce the occurrence of merge conflicts.

We use SpecFlow to write integration tests against Azure. In this post we share an Open Source SpecFlow extension for the Azure Storage Emulator.

A CDN, short for Content Delivery Network, is essentially a network of servers set-up, in various geographic locations, with the aim of speeding up the delivery of content to end-users across the Internet.

Everything in Azure runs in Coordinated Universal Time; learn how to deal with Daylight saving time in Azure Automation, so your jobs still run on time.

If you have private NuGet feeds, restoring packages during a CI/CD process can be a challenge. This post provides a solution when working with Azure App Service.

One of the great benefits of using SpecFlow is that it allows you to write your specifications in a human readable format. Learn how you can create reusable step argument transformations to apply custom transformations to your parameters, so that you can keep your specifications easy to read.

We're huge fans of SpecFlow. We harvested 25 reusable steps from our various open source projects into a new extension that you can use to reduce your own boilerplate.

Just because you're using the cloud, doesn't mean you don't use traditional DTAP environments. But you do need to configure your cloud services to understand them.

Hiring developers is hard. Really hard. Here are some tips on how to make it easier on yourself.

If you were learning to programme today, which language should you choose, and why?

In this post we demonstrate how to use New Relic to monitor an Azure Cloud Service Worker Role, step by step.

Endjin.Retry is our simple .NET library for handling transient errors, to make your Cloud applications more resilient and reliable.

We've open sourced a lightweight .NET based licensing framework we've been using internally over the last couple of years; in this post I'm going to highlight some real world usage scenarios.

Endjin.Licensing is our .NET based licensing framework; in this post we highlight its extensibility features, demonstrating how to add custom license validation logic.

Endjin.Licensing is our .NET based licensing framework; in this post we show how to create and validate a license using C#

We've open sourced a lightweight .NET based licensing framework; in this post we flesh out the behaviours we want the framework to support using Gherkin flavoured BDD specifications.

We've open sourced a lightweight .NET based licensing framework we've been using internally over the last couple of years. In this post I explain why we created it in the first place, rather than using existing offerings.

Learn how to use diagnostics in Azure Virtual Machines and Cloud Service Web or Worker Roles using the Azure SDK.

TPL Dataflow is one of the most powerful, yet unknown framworks contained within .NET. If you need to do high performance data processing TPL Dataflow should be your first port of call.

One of the strongest selling points of cloud computing is that you only pay for what you use. Running virtual machines can become expensive, but you can save significant money if you turn those VMs off outside of office hours.

We've delivered a number of Elasticsearch solutions on Azure. In this second post in the series, we share some useful tips.

How to use an $injector service to avoid a circular dependency error dynamically resolving templates in a templateRepository.

In this post we show how you can render a container based on content-type

Meta-Runners allow you to easily create reusable build components for TeamCity, in this post I demonstrate how to create a Meta-Runner to wrap Jasmine BDD Framework test runner.

In this post, Mike demonstrates how you can test AngularJS with Visual Studio, ReSharper and TeamCity for the full local and CI/CD DevOps experience.

We've built a number of Elasticsearch clusters on Microsoft Azure. This blog post contains some of our top tips and gotchas.

There's a lot of documentation available around NuGet and how to create/publish packages, etc. But when I looked for a simple step-by-step guide on how to test a package locally, I couldn't find any.

Transient failures can happen at any time. There are many useful frameworks for .NET, but what about PowerShell?

You can easily notify NewRelic that a deployment has occured. In this post I demonstrate how to turn a script into a reusable TeamCity Metarunner.

One way to manage a button visual state in iOS is by setting a different background image for each one of the UIControlState values available...

Having described the problem space using Marble Diagrams, it's now time to create a real solution using Rx and the Observer pattern to process data from Windows Event Log.

This blog post delves into using Rx to process the messages received from Windows Event Logs, so that they can be shaped in a way that is useful to us to consume.

Semantic logging enables much richer diagnostics and analysis. It is supported in Windows and in .NET. This post explores the problem space. Others in the series explore how we can use Reactive Extensions to enable some powerful scenarios.

Learn how to use PowerShell Remoting to connect to an Azure Virtual Machine; a useful technique for managing servers like cattle, not pets.

This post shows how to use your Office 365 SMTP relay to enable email notification from TeamCity and YouTrack hosted in Azure.

If you use Azure Management Studio, you can quickly setup your connections by importing your publish settings...

A quick tip of how to reclaim up to 10GB of space after updating to Windows 8.1

A quick tip for updating your Azure cloud service configuration while running in the emulator

1601 was the year that Pierre de Fermat and King Louis XIII of France were born, Robert Devereux was beheaded in the Tower of London, the Dutch defeated the Portuguese navy in the battle of Bantam Bay and the year Shakespeare's Hamlet is thought to have been performed for the first time. Monday January, 1st 1601 (in the Gregorian calendar) was a pretty uneventful day yet the first day of the 17th century is affecting millions today.

In this post we look at the history and motivations behind the Bootstrap CSS library, and the goals of the project.

In this post we'll look at recursion in F#...In this post we'll look at recursion in F#...

In this blog post, I provide a how-to guide for automating your TeamCity backups using a PowerShell script.

In this post we delve deeper into Function and Logic and look at minimizing Boolean Expressions with F#

Sometime upgrading in-place is no longer an option and you need to migrate to a new server. This step-by-step guide takes you through the process of migrating a TeamCity instance.

In this post, we'll look at how our function can work more like the other logical F# operators we've already used.

Just so that I never ever forget this again. Here's how to assign a keyboard shortcut to collapse all projects in Visual Studio Solution Explorer.

In this post, we'll learn how to use F# to ease the pain for us.

I've always wondered what sudo means when I use it to run a command in a terminal.

See how to use Bootstrap 3 to create a full-page bleed.

In this post, we'll look at how we can bring logic to bear on our problems.

Last post on the topic and links to all the other entries centred around troubleshooting/setting up your Xamarin mobile dev environment.

Xamarin lets you develop iOS applications using Visual Studio. This is obviously great for .NET Developers except that you currently have to go to Xcode (Apple's Developer tool) if you want to create the UI using a designer tool.

In post, we're going to look at the data memory in more detail, and learn how we can represent numbers in a computer.

If you run Windows 8 on your Mac with VMware Fusion 5.0 , you might get the following error message when starting the Windows Phone emulator for the first time: The Windows Phone Emulator wasn't able to create the virtual machine.

Today my Xamarin trial expired - Sadface. But endjin generously supplied me with a new Xamarin.Android and Xamarin.iOS Business edition license, things were looking up - Happyface! However after activating the new license and upgrading to a newer version of Xamarin Studio on both my Mac and the guest Windows 8 OS, my master solution containing all the projects for the different platforms (Android, iOS and Windows Phone) was no longer building.

In this post we delve into a bug we discovered with Angular.JS and Bootstrap that appears in IE 7.

In this post we're going to take a look at algorithms.

After going through the Xamarin installation instructions for Mac and Windows , I ended up in a situation where the AVD Manager ( Android Virtual Device Manager ) on my Windows VM would not let me create a new AVD...

Let's start our exploration of this architecture by looking at the Program Instructions memory.

A short explanation of Windows Phone capabilities and how to enable the camera.

Learn how to debug the endjin composition framework.

In this post, we're going to be taking a look at one representation of the hardware box - from a programmer's perspective.

A quick fix to error 0x64 when registering a new Windows Phone device.

Learn how to use the endjin composition framework inside ASP.NET MVC or Web API

The other day I wanted to bring up the Windows "Program and Features" panel using the run command (Win+R or just start typing in the Start screen in Win 8). Something I've done countless number of times in the past. For some reason, I had a complete blank and couldn't recall what that particular command was. So I thought it would be good to have a couple of tips and some of the most useful run commands for Developers (and everybody else) in one place.

Learn how to use the endjin composition framework content factory

Dealing with Transient Faults is absolutely essential when working in The Cloud. We delve into the library we've created for dealing with this situation.

In this post, we're going to set up the tools that we're going to use in the rest of this course on Windows or Linux.

In this step-by-step guide, we'll take you through the process of setting up an F# REPL environment on Linux.

In this step-by-step guide, we'll take you through the process of setting up an F# REPL environment on Windows.

Yesterday I attended the "C# and Mvvm - Developing apps for all of Android, iPhone and Windows" event hosted by Stuart Lodge at Modern Jago. In preparation for the day I had the daunting task of setting up my Mac for cross platform development with Xamarin. While most of it was fairly straight forward and well documented, I came across a few gotchas worth blogging about.

Learn how to use the endjin composition framework for dependency injection.

Learn why we created the endjin composition framework for dependency injection.

At endjin we believe in collaboration and the ability to pull together expertise and ideas. In this post we talk about the collaborative efforts between designers and developers the importance of communication, a step by step guide followed by some handy tips.

Splatting is one of the most powerful, yet underused features of PowerShell. In this post we cover a walkthough of how to use this feature.

A proof of concept is not a quick and dirty hack, it's not a demo, or a technical spike.

In the final part of this series, we cover how to use TeamCity's feature branch abilities to support the GitFlow process.

See how to create a responsive website layout using Bootstrap.

We ran a retrospective of our first few Bootstrap-based HTML5/Javascript projects a few weeks back, and distilled some of the output into these top tips

If you were learning to programme today, which language should you choose, and why?

If you were learning to programme today, which language should you choose, and why?

This post finally covers the nitty-gritty of how you use the GitFlow extensions to drive the workflow.

In this post we show you how to get up and running with GitFlow.

Adopting Git means creating an entirely new mental model about how to version control your source code. Once you make the jump, there's no going back.

We take a look at the state of HTML and JavaScript in 2013; the good, the bad and the ugly.

Some thoughts on RavenDB after using it to build a content-managed website.

Discover how to build Twilio voice apps using asp.net MVC and debug it using port forwarding tools.

A quick example of how to set up integration testing for HttpClient and HttpServer

Endjin are proudly sponsoring the Agile Milton Keynes user group.

Sql Server Spatial Types Assembly is a hidden gem. In this post we show how to use SqlGeography.STGeomFromText and STDistance distance (in meters) between the two points.

A quick guide to using the endjin composition framework with ASP.NET MVC Applications.

A review of the Windows 8 App bootcamp help at Microsoft.

Mike starts his first day as an Apprentice with an introduction to PowerShell and being onboarded to endjin's various tools and platforms, while attempting to automate the entire process.

To celebrate joining JetBrains Development Academy Board, we release a PowerShell modules to make working with TeamCity easier.

PowerShell is fantastic language for DevOps, automation and general scripting. Every developer should be familiar with it; here's a guide to some useful resources to help you learn it.

How does Expression Blend managed to find the Visual States exposed by the standard controls? How could you do the same with your own code?

We've added convention over configuration features to our Dependency Injection library - the endjin composition framework, to help improve your productivity.

MongoDB has been taken a large amount of mindshare in the NoSQL space. In this blog post we share a simple step-by-step guide on how to get started as a .NET developer.

My last post caused a number of responses from the community. I discuss them here and provide a little bit more context.

In this post I delve into some performance analysis of an expensive loop that was taking over 200 seconds to run.