A Developer’s Manifesto

1. Every software project is constrained by time, budget, and scope.

2. The old truism has it that the customer may choose only two of the three.

2.1. Vendor promises, hype cycles, new methodologies, new tools, artificial intelligence, and silver bullets cannot alter these project constraints.

2.2. In large organizations there is no single customer.

2.2.1. Executives control the purse strings. They have an idea of how long the project should take and how much money they want to spend. But they have only a vague notion of the scope.

2.2.2. Line of business managers have an idea of the scope and the features they want but very little negotiation power on the time and budget.

2.2.3. Therefore, most projects begin with an implicit or explicit decision to fix the time and budget.

2.3. Problems arise when the schedule is determined by the wrong people (senior managers, leadership and executives) at the wrong time (at project start before scope is analyzed).

2.4. Analysis of and negotiations around scope are often left to the software team and the line of business customers who will work with the team.

2.4.1. The software team has no negotiation power on scope.

2.4.2. The customer curates the list of features. This list might or might not be possible to implement within the time and budget. More often than not it represents everything the customer wants along with everything they need.

2.4.3. Therefore, it is rare that the scope is in alignment with the time and budget.

2.5. Even when at project start the scope is triaged, curated, and prioritized the customer’s natural desire to have all of their features can overwhelm the project. This is scope creep.

3. Given a relatively fixed time, budget, and scope creep the project will end in one of three ways:

    • Senior stakeholders adjust the time and budget.
    • Scope is reduced.
    • Developers do a death march to close the gap.

4. More often than not, time and budget are non-negotiable. And line customers do not want to lose any of their features. Some money might be found, and some scope might be curtailed. But practically speaking, if nothing substantial is done the death march is the only option left.

4.1. The death march is a fool’s errand and should be avoided at all costs.

4.1.1. Failure to avoid the death march means the team has accepted responsibility for the inevitable slippages that were baked in from the very start.

5. If Agile principles are followed, then there is a remedy.

5.1. The disciplined development team finishes all stories in the sprint.

5.2. The team must work like the proverbial man in the grocery store: stick to the list, no browsing, and move with efficiency.

5.3. At the end of every sprint the working software could be deployed to production if the customer wishes it.

5.4. If these principles are followed then time, budget, and scope are never the development team’s problem to solve. For if time and money have run out the product can still be shipped. And if all features have yet to be implemented, then it is up to the customers to decide what they wish to do.

6. Wise developers distinguish between what they can and cannot control. They work diligently on the former and let go of the latter.

Pretty Good Pipeline (PGP)

With apologies to Phil Zimmermann, I’ve put together a “pretty good pipeline” using Azure Pipelines, a multi-stage YAML file, and a couple of ARM templates to deploy a typical .NET Core 3.1 API to an Azure App Service. This won’t be a walkthrough or a “how to” so much as general guidance with links to relevant documentation for more information. From a high-level the pipeline will look something like this diagram:

I am not going to talk about containerization, A/B testing, the latest trends in DevOps, or continuous delivery where a dozen production releases are all in a day’s work.  This is just vanilla guidance for a typical mid-sized shop. If this still interests you then read on.

Continue reading “Pretty Good Pipeline (PGP)”

JSON Variable Substitution in Multi-Stage YAML Pipeline with Azure Key Vault

In my last post I showed how to configure JSON variable substitution with secret variables right in the pipeline. Now in this follow up post I want to expand on that to show how you could instead store your secrets in an Azure Key Vault and reference them in the pipeline. See the publicly visible TimeApi project on Azure DevOps for the source code, ARM templates, and the YAML file.

Continue reading “JSON Variable Substitution in Multi-Stage YAML Pipeline with Azure Key Vault”

JSON Variable Substitution in Multi-Stage YAML Azure Pipeline

If you made it past that long and technical article title then you are here for a purpose. Maybe you’re just getting started with the relatively new YAML experience in Azure Pipelines.  Or maybe you’ve been doing this awhile and found the variables guidance to be less than clear. In any case, in this article I’m going to show how to reference pipeline variables in an Azure Pipelines CI/CD multi-stage YAML file. See also the followup post to this one in which variables are moved into an Azure Key Vault.

Continue reading “JSON Variable Substitution in Multi-Stage YAML Azure Pipeline”

Deep Dive: Azure DevOps Version Control

Introduction

Let’s talk about version control in Azure DevOps. If you want to automate your builds in Azure DevOps (or any DevOps process) then you must use version control.  So if you need to get up to speed check out these resource (here, here, and here).

Now let’s dive deep into the whole enchilada: files, commits, pushes, branches, tags, pull requests, and of course integration of all this goodness from within the Visual Studio IDE. If you want to see the source code for the sample project I used for this post go to my repo here: https://github.com/jamesstill/WidgetApi.

When you provision a new project you have two choices within the tool for native version control: Git or Team Foundation Version Control (TFVC). Personally, I haven’t used TFVC since I worked with an on-prem TFS Server several years ago. There’s nothing wrong with it. It’s just that Git has quickly become the de facto standard. So if you’ve got a brand new project just choose Git and be done with it.

If you’re not familiar with Azure DevOps you should probably go read my four-part series before continuing. I’m going to assume you already have an account and know your way around. Continue reading “Deep Dive: Azure DevOps Version Control”

NuGet Package Feeds on Azure DevOps

One of my favorite features of Azure DevOps is its package management feature where you can publish NuGet packages to your own organization’s feed. Packages in your feed can be referenced by other projects in the CI/CD pipeline or through Visual Studio. In this walkthrough I’ll give a simple example of how to use it. I’ll assume you’re comfortable with Azure DevOps. If you’re not familiar with the tool see my four-part series on the subject.

That creamy NuGet center!

Continue reading “NuGet Package Feeds on Azure DevOps”

From Soup to Nuts: Azure DevOps with Visual Studio 2017

This is the introductory post in a four part series walking through the process of creating a project in Visual Studio and building out a complete CI/CD pipeline to get that code into production on Azure using Azure DevOps.

Here’s a rough outline of where I think this series will go. As soon as I have the content ready I’ll link to them from here:

Part 1: Publish to an Azure DevOps Repository

Part 2: Setting up a Build Pipeline in Azure DevOps

Part 3: Setting up a Release Pipeline in Azure DevOps

Part 4: Adding a Database to the Project

A little context… Lately I’ve been using the Eclipse plugin Subversive for source control on my java-based projects, which uses an on-prem SVN server. For C# projects I use the Visual Studio plugin VisualSVN. Back in the old days I used an on-prem TFS server. Before that VSS which I’ll just leave that right there. So I’ve used SVN for many years and I have no complaints about it in particular or concurrent version control systems in general. But this series isn’t about those tools or centralized version control. And it’s not about Git Bash or shelling out to the command line from GitHub Desktop or anything like that.  Download the Pro Git book if you want to dive deep into that area. 

I’ve also used TFS v1.0 and before that NAnt and then CruiseControl somewhere along the line. Currently my place of work uses TeamCity for builds, NUnit for tests, Octopus for deployments and probably other things like DbUp for database scripting. And I’ve deployed straight to Azure from Visual Studio more times than I can count. But guess what? This series isn’t about any of those things either. In this series I want to help you to take your game up to the next level so that your pipeline to production is fully automated. And I want to keep it as simple as possible. So let’s get started at Part 1.

Part 4: Adding a Database to the Project

This is Part 4 in a  series on Azure DevOps.

In  Part 1 I created a simple web app called WidgetApi. I then put it under source control and pushed it up to an Azure DevOps repo. In Part 2 I configured a build pipeline and made a code change to trigger that build with continuous integration. In Part 3 I set up a release pipeline and deployed our build artifacts to Azure. In this part I’m going to add a database to WidgetApi and use a DACPAC file to bundle database changes for deployment in the release pipeline. Finally, I’ll configure a production environment with an approval process.

Continue reading “Part 4: Adding a Database to the Project”

Part 3: Setting up a Release Pipeline in Azure DevOps

This is Part 3 in a  series on Azure DevOps.

In  Part 1 I created a simple web app called WidgetApi. I then put it under source control and pushed it up to an Azure DevOps repo. In Part 2 I configured a build pipeline and made a code change to trigger that build with continuous integration. In this part we’re going to create a release pipeline that deploys our build artifacts to Azure.

Continue reading “Part 3: Setting up a Release Pipeline in Azure DevOps”

Part 2: Setting up a Build Pipeline in Azure DevOps

This is Part 2 in a series on Azure DevOps.

In Part 1 I created a simple web app called WidgetApi. I then put it under source control and pushed it up to an Azure DevOps repo. In this part we’re going to set up a build and then change our code to trigger a continuous integration build. Open the browser and go to your Azure DevOps portal. You should see all your pushed commits there from Part 1. Awesome. Now there’s a couple of housekeeping things to do before we set up the build.

Shout out to https://devrant.com/rants/1535091/ci-cd-in-a-nutshell

Continue reading “Part 2: Setting up a Build Pipeline in Azure DevOps”