Disciplined Agile Delivery (DAD)

Background

Disciplined Agile Delivery (DAD) enables teams to make simplified process decisions around incremental and iterative solution delivery. DAD builds on the many practices espoused by advocates of agile software development, including scrum, agile modeling and lean software development.   

DAD has been identified as a means of moving to the next evolution of Scrum.  DAD provides a carefully constructed mechanism that not only streamlines IT work, but most importantly, enables scaling.  DAD is a hybrid agile approach to enterprise IT solution delivery that provides a solid foundation from which to scale from.   

DAD recognizes not only the importance of networks of cross-functional teams, it also explicitly offers support for scaling key practices across complex working environments using techniques that link software development efforts into robust software delivery events.

Toolkit 

The Disciplined Agile (DA) process-decision toolkit provides straightforward guidance to help people, teams, and organizations streamline their processes in an event-sensitive manner; providing a solid foundation for business agility.  It does this by showing how the various activities such as Solution Delivery (software development), IT Operations, Enterprise Architecture, Portfolio Management, Security, Finance and Procurement work together as a cohesive team.  DA describes what these activities should address; provides a range of options for doing so; and details the tradeoffs associated with each option.  

To begin your adoption of DAD it is best to start at the beginning and step incrementally into the adoption of DAD.  

There are four areas within the DA toolkit:

  1. Disciplined Agile Delivery (DAD) 
  2. Disciplined DevOps 
  3. Disciplined Agile IT (DAIT)
  4. Disciplined Agile Enterprise (DAE)

This article will concentrate on first DA area (DAD) and specifically, Way of Working (WoW) 

DAD is the foundational layer of the DA toolkit.  It promotes goal-based rather than a prescriptive strategy and enables teams to choose their way of working (WoW).  Depicted below is process goals of DAD.

Figure 1. The process goals of Disciplined Agile Delivery (DAD)

 

The goals are broken into four areas: Inception, Construction, Transition and Ongoing.  Inception gets the team going in the right direction before any development work begins.  Construction is where the team incrementally builds the solution, Transition is the where the solution is released into Production.  And finally, Ongoing is where the team improves their skills and betters adapts themselves to the organization’s Enterprise.    

Providing choices rather than prescriptions and, by guiding people through these process goals, DAD enables teams to adopt a continuous improvement approach to solution delivery.  

Way of Working (WoW) 

When teams initially form, they need to invest in putting together their initial WoW.  This includes choosing the lifecycle that best suits their project, selecting the tools they will use, and setting up the physical work environment.  Because initiating a project tends to be very different than executing on the development of a solution, teams tend to tailor their WoW on what they are comfortable with and has been their tried and true way of doing the WoW.  However, teams can evolve their WoW based upon new learnings.  In considering your WoW the team must ask themselves the questions listed below.  This helps the team get organized in the manner the team is used to.    

  • How will we organize our physical workspace?
  • How will we communicate within the team?
  • How will we collaborate within the team?
  • What lifecycle will we follow?
  • How do we explore an existing process?
  • What processes/practices will we initially adopt?
  • How will we identify potential improvements?
  • How can we reuse existing practices/strategies?
  • How will we implement potential improvements within the team?
  • How will we capture our WoW?
  • How will we share effectives practices with others within our organization?
  • What software tools will we adopt?

The figure below depicts different ways to evolve your WoW and, as you can see there are many options:

 

Deciding upon your WoW is critical during the Inception Phase since it sets the framework you need to move to the Construction Phase.  During all the various DAD phases, the WoW is constantly reviewed, evaluated and improved upon.

Understanding ASP.NET Middleware

Understanding ASP.NET Middleware

In ASP.NET Core, middleware is the term used for components that form the Request Pipeline.

The pipeline request is similar to a chain; it can contain multiple middleware. These components will handle the request in sequence; each component will inspect the request and decide whether it should be passed to the next middleware or just generate a response interrupting the chain.

Once the request has been handled, a response will be generated and send back to the client passing along the chain.

Execution Order

Middleware’s will execute in the same order they are registered when handling requests and in the reverse order when handling responses.

Check the example below:

How to create a Middleware

Middleware components don’t implement interfaces or derive from classes, It simply has a constructor that takes RequestDelegate as parameter and implements the Invoke Method.

The RequestDelegate represents the next Middleware component of the chain and the Invoke method is called when the component receives a request.

For example:

Creating Content-Generating Middleware

The most important type of middleware generates content for clients, and it is this category to which MVC belongs.

This kind of middleware is used when you want to generate some content and send it back to the client without the need of dealing with all the MVC complexity.

Implementation:

 

Creating Short-Circuiting Middleware

Short-Circuiting Middleware Components are used when you want to inspect the request and decide if the request should be passed to the next component.

For example, the below process is checking if the request contains the User-Id header, if not the middleware will break the chain and return a 401-Unauthorized response to the client.

 

Creating Request-Editing Middleware

The next type of middleware component examined doesn’t generate a response. Instead, it changes requests before they reach other components later in the chain. This kind of middleware is mainly used for platform integration to enrich the ASP.NET Core representation of an HTTP request with platform-specific features.

The example below is to demonstrate the check that if the request contains a blank User-Id in the header; if yes it will be removed.

 

 

Interacting with another Middleware

Middleware components can interact with each other, let’s consider that RequestEditMiddleware is executed before the ShortCircuitMiddleware.

In that case if a request contains blank User-Id Header the RequestEditMiddleware will remove that header from the request and call the next component, which is the ShortCircuitMiddleware, the ShortCircuitMiddleware won’t find the header User-Id and will break the chain returning a 401 response to the client.

Registering a Middleware

Now that we already know how to create our own custom components, how do we use it?

It’s simple, in the Startup class there is a method called Configured which is responsible to setup how the application will handle requests.

This method has a parameter of type IApplicationBuilder, that is the object we use to register our components.

See example below:

However, there is a more efficient way to register the components, for that we need to create some extension methods.

See below:

After creating the extension methods all we have to do is register the components using it.

 

ASP.NET Core and Docker for Beginners

Introduction:

Docker is an open, lightweight platform for developing, shipping and running applications using container technology. Docker provides container solutions for developers, architects, DevOps, and IT People. It can run on Linux, Windows, Mac OS and most the cloud providers like AWS, Azure, Google etc..

What is Docker?

Docker is all about running a single program inside separated environments. It is an open source platform with can be used to package, distribute and run applications in different environments.

Let start understanding by an example,


Applications 1 & 3 will stop working because they need a different framework to run. What can be done now? The above diagram shows, we have three applications running; however, all of the application use the same framework. What will happen if App 1 required different Framework version like 1.0, app 2 needs v2.0, app 3 needs v.3.0. As a result only App 2 will work because our framework installed is v2.0.

One way is to use three different systems for all three applications, but it will be very expensive and maintening them will also be very difficult.

This is how “DOCKER” comes into play. Docker will make sure each application has its own facilities rather than common facilities.

Docker will do something like this.


Build the ASP.Net Core and Docker Packages

Docker will create a package that can run in different environments.

To build an app in Docker, first we need an app to Dockerize.

Docker allows you to build an application in pretty much the same way you would create an application to run on your local machine.

When we create application make sure enable the Docker support and also make sure you have it installed by going to:

https://www.docker.com/products/docker-desktop

Note: Make sure Docker is installed .Otherwise you’ll get the below error:

Installing this (mac or pc) will run docker and allow you to create and host docker containers. Microsoft Visual Studio will use Docker Desktop to host your app inside of during development to allow you to develop or test in.

The trick is to get a new item in your launchSettings.json:

This, in conjunction with a docker file in your project (just called “Dockerfile” without an extension) that builds a container, hosts it, and allows you to debug it remotely.

Writing a Dockerfile:

What is Dockerfile?

In short, Dockerfile contains a series of instructions which define how to construct an image:

Below are the common commands:

FROM

This command specifies the base image, eg: Microsoft/aspnetcore:2.0

WORKDIR

Changes the working directory for subsequent instructions in the Dockerfile

COPY

Copies files from source to destination

RUN

Executes a command directly in the container

EXPOSE

Sets a specific port internally to the container

VOLUME

Usually, it is used to map a physical directory on our machine to the logical directory in the container instead.

ENTRYPOINT

Specifies which application will run in the container created from the image.

To use some of the commands, First create Dockerfile in your application:

Then write Dockerfile for ASP.NET Core app, you must first know if you want to use the Development Environment or the Production Environment.

In development environment you need an image that contains a compiler and allows compiling directly in the container, and for that, use Microsoft/aspnetcore-build directly from the DockerHub (Docker Repository).

In Production environment you do not need a compiler because it will have to build the application externally from the image, integrate all built files in the image, and just use a lightweight image containing the .NET Core Runtime Microsoft/aspnetcore to execute your application.

The Dockerfile is pretty simple (if you’re familiar with Docker) though it’s very automated, so you don’t have to know how it works:

It creates a container from a slim image with ASP.NET Core 2.2 , builds the project and publishes to get a copy of the project in a container. To test/debug with docker, just pick the ‘Docker’ option in the debugging dropdown:

After that, in cmd type:

docker build. –t rootandadmin/DockerApp –f Dockerfile

Now, you have your image and check the type:

docker images

You have your image rootandadmin/DockerApp but as this image is dead so you have to make it alive. For this you will need to create a container. There is a big difference between Image and Container; a container is a process that contains an image and executes it.

Then to create containers from our image type this.

docker create command –p 555:80 –name rootandadmin/DockerApp01 rootandadmin/DockerApp

docker start rootandadmin/ DockerApp01

You can try to access your DockeApp in the browser using the following address.

localhost://555/ DockerApp/Home