
[Azure Devops](https://azure.microsoft.com/en-us/services/devops/) is a set of tools that allow you to automate the building, testing and deploying of your applications. It supports defining how you build your application in as a pipeline file that lives along side your code rather than as manual steps done in a UI. While visual editors might be convenient at first it can quickly become very difficult to manage especially if you have a complex system with many people working on it.

This article is will guide you through how to build and package a React app using Azure Devops by defining a our build in a YAML file. The article doesn't go into deploying the package as that is going to differ depending on your host and I wanted to just focus on the React part for now.

You can explore the code directly by going to [the Github repository for this article](https://github.com/sethreidnz/azure-devops-create-react-app).

The project was created by running the following command to use the [Create React App](https://reactjs.org/docs/create-a-new-react-app.html) to create the base project:

```bash
npx create-react-app my-app
```

This leaves us with the following structure, including the `azure-pipeline.yml` file which we will look at next.

```yaml
my-app/
  # React app here
azure-pipelines.yml
```

## Examining the YAML file

In the repo mentioned about there is a file [azure-pipelines.yml](https://github.com/sethreidnz/azure-devops-create-react-app/blob/main/azure-pipelines.yml). AT first glance there is quite a lot going on in that file but don't work I'm going to explain each step below.

### Defining the virtual machine image

The first section of the file selects the Virtual Machine (VM) image that the build will run on. You can choose between the [available images on Azure Devops](https://docs.microsoft.com/en-us/azure/devops/pipelines/agents/hosted?view=vsts&tabs=yaml#use-a-microsoft-hosted-agent) which includes Linux, Windows and MacOS:

```yaml
pool:
  vmImage: "ubuntu-latest"
```

Here I am using Ubuntu "ubuntu-latest" since I don't mind which version exactly and would rather keep my build agent up to date.

### Defining build variables

Azure Build Pipeline will give you a number of predefined [build](https://docs.microsoft.com/en-us/azure/devops/pipelines/build/variables?view=vsts) and [release](https://docs.microsoft.com/en-us/azure/devops/pipelines/release/variables?view=vsts) variables and you can also define your own. This means that you don't need to repeat the same strings and values throughout your build.

In this example I have defined `projectFolder` and `buildOutputFolder` for using later in the script:

```yaml
# define variables to use during the build
variables:
  projectFolder: "src/react"
  buildOutputFolder: "src/react/build"
```

### Defining the steps of the build

This is the main section of your build where you define the steps of your build. You can use custom scripts as well as use huge list of the [build-in tasks](https://docs.microsoft.com/en-us/azure/devops/pipelines/tasks/?view=vsts) which are available.

First you have the key word `steps:` which you can then follow up with any number of custom scripts or pre-defined tasks:

```yaml
# define the steps of the build
steps:
```

#### Running custom scripts

First I have defined a script that will run the install and build for the React application:

```yaml
## Run the npm install/build
- script: |
    pushd $(projectFolder) && npm install && popd
    pushd $(projectFolder) && npm run build && popd
```

Notice how I have used the PowerShell syntax `$(projectFolder)` to use variables I defined earlier. These scripts can be used to script any task and on Linux/MacOS will run using bash, while on Windows they will use cmd.exe.

#### Running build in tasks

A task is the building block for defining automation in a Azure Devops Pipeline. A talk is just a packaged set of scripts with inputs that allow you to carry out a task.

I have used the following tasks:

- [`CopyFiles`](https://docs.microsoft.com/en-us/azure/devops/pipelines/tasks/utility/copy-files?view=vsts&tabs=yaml) - to copy the files from the React build output into the staging directory.
- [`ArchiveFiles`](https://docs.microsoft.com/en-us/azure/devops/pipelines/tasks/utility/archive-files?view=vsts) to create a zip from the staging directory
- [`PublishBuildArtifacts`](https://docs.microsoft.com/en-us/azure/devops/pipelines/tasks/utility/publish-build-artifacts?view=vsts) to publish a package from the build for later deployment.

This looks like this this in the YAML file:

```yaml
## Copy the client to the staging directory
- task: CopyFiles@2
  inputs:
    sourceFolder: "$(buildOutputFolder)"
    contents: "**/*"
    targetFolder: "$(Build.ArtifactStagingDirectory)"
    cleanTargetFolder: true

## Archive the files into a zip file for publishing
- task: ArchiveFiles@2
  inputs:
    rootFolderOrFile: $(Build.ArtifactStagingDirectory)
    archiveType: "zip"
    archiveFile: "$(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip"
    includeRootFolder: false

## Publish the zip file
- task: PublishBuildArtifacts@1
  inputs:
    pathtoPublish: "$(Build.ArtifactStagingDirectory)/$(Build.BuildId).zip"
```

Notice again how I am using the PowerShell syntax `$(Build.ArtifactStagingDirectory)'` to refer to a variable but this time I am using the predefined `Build.ArtifactStagingDirectory` variable.

## What does the PublishBuildArtifacts step actually do?

I wanted to point out specifically that this step in the build file publishes the artifacts to the build itself within Azure Devops. It adds the specified zip file to the build for other pipelines to pick up. For example you would likely couple this build with a release pipeline to take the published release package through to production. This article is just focussing on the build part and that is why we stop with the PublishBuildArtifacts step

## Creating your own build

For more information on how to create a new build pipeline see the documentation [getting started guide](https://docs.microsoft.com/en-us/azure/devops/pipelines/get-started-yaml?view=vsts).

Once you've done that you will just need to copy in the [React Example YAML file](https://github.com/sethreidnz/azure-devops-examples/blob/master/react-pipeline.yml) to your `azure-pipelines.yml` and make sure that the `projectFolder` and `buildOutputFolder` are pointing to your react project.

## Useful resources

- [How to use Azure Pipelines](https://docs.microsoft.com/en-us/azure/devops/pipelines/get-started/pipelines-get-started?toc=/azure/devops/pipelines/toc.json&bc=/azure/devops/boards/pipelines/breadcrumb/toc.json&view=vsts)
- [Key concepts of Azure Pipelines](https://docs.microsoft.com/en-us/azure/devops/pipelines/get-started/key-pipelines-concepts?toc=/azure/devops/pipelines/toc.json&bc=/azure/devops/boards/pipelines/breadcrumb/toc.json&view=vsts)
- [Azure Pipelines YAML schema](https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts)
- [Catalogue of build in tasks for Azure Pipelines](https://docs.microsoft.com/en-us/azure/devops/pipelines/tasks/?view=vsts)



[Azure Devops](https://azure.microsoft.com/en-us/services/devops/) is the new and improved version of VSTS which now allows you to define your build with configuration-as-code using [YAML](https://yaml.org/) instead of the visual editor to create your build pipelines. In fact it is now the default experience and when you create a new Build Pipeline it will create a new PR to add a `azure-pipeline.yml` to your repository. But what if you want to use multiple different build definitions within the same repo or give your YAML file a different name? This article will show you how.

## Creating a build with a custom YAML file

First you need to create a new Build Pipeline in your project. Click on **Pipelines** in the left navigation, click on **Builds** and click **New build pipeline**.

![Creating a new build pipeline in Azure Devops](/content/Screen-Shot-2019-01-12-at-7.38.39-PM.png)

Counterintuitively, in order to select your own custom YAML file, you need to **use the visual designer**. To do this click on **"Use the visual designer"**.

![Using the visual designer in Azure Devops](/content/use-the-visual-design-1024x382.png)

After choosing to use the visual designer you will have to select the location of the repository you want to connect to. Select the location you want, in my case I'm using Github, then complete the rest of the required fields to chose the repository you want to trigger builds from.

The next step is to select a template and for this choose **YAML**:

![Choosing YAML build template](/content/Screen-Shot-2019-01-12-at-7.21.49-PM.png)

The final step is to enter the path to your YAML file in the repository, or you can click the ellipsis to select the file from your repository.

![Adding a YAML file path](/content/add-custom-yaml-1024x219.png)

Now you can press **Save and queue** from the top menu to test your build.

## Creating multiple builds with different YAML files

Now that you have setup this one build with a custom YAML file path you can do this process again to create a new build with a different YAML file. This means you can create as many builds as you like with as many different YAML build definitions as you need.


This article is an update to a [previous article](https://sethreid.co.nz/delivering-single-page-apps-aspnet-core/) where I described how to serve a single page JavaScript app with ASP.NET Core. The reason for the update is that I've changed the way that I approach doing this. I think the new approach is easier and it has the benefit of being more performant, since it uses IIS to serve static files rather than the ASP.NET Core middleware. This example is using React and [Create React App](https://github.com/facebook/create-react-app), but it will work with any modern JavaScript framework, for example Angular or Vue, and where there would be some requirement to alter my approach I'll note it.

> **Note:** To see a complete implementation of this approach see [this Github repository](https://github.com/sethreidnz/aspnet-core-spa).

## What are the goals of this approach?

When using modern JavaScript frameworks you get a lot of productivity wins by using the supported CLI or project generation tools. In this case I am using [Create React App](https://github.com/facebook/create-react-app) which, among other things, provides a live reloading development server.

My high level goals with this approach are:

- Use the default development experience from Create React App for building my client app
- Use ASP.NET as my API
- Serve and deploy the production build of the client app with the API
- Deploy to an Azure Web App

This way I get the best of both worlds; I can use Create React App and I can also use .NET core as my backend without compromises. It also means the frontend team can point the client app to a remote deployment of the API and not have to run the it on their machine when they shouldn't need to, and the backend developers don't need to run the client application either.

## How does the approach work?

The implementation involves the following:

- Two separate projects - `src/client` (Create React App) and `src/server` (ASP.NET Core MVC)
- Using Create React App `npm start` in development - Use this during development and point API requests to the server at `http://localhost:5000`
- Enable CORS in development mode - To allow for the front end application
- Use web.config reroute rules - Ensure that the static files are served by IIS but API requests are let through to the MVC backend

I generally deploy these applications to Azure but it will work in any IIS website. Keep reading to understand how I've achieved this approach.

### Two separate projects

If you look in the companion [Github repository](https://github.com/sethreidnz/aspnet-core-spa) you will see two folders `src/client` and `src/server`. These are essentially unrelated projects - you are able to run them independently with their own runtimes.

### Using Create React App `npm start` in development

This can be achieved by using the existing [dotenv](https://www.npmjs.com/package/dotenv) support in Create React App, which allows you to set a different value for your API host when running with `npm start` and when you build the production app with `npm run build`. This is done with the two files in the repo [`src/client/.env`](https://github.com/sethreidnz/aspnet-core-spa/blob/master/src/client/.env) and [`src/client/.env.production`](https://github.com/sethreidnz/aspnet-core-spa/blob/master/src/client/.env.production).

> **Note:** This approach would have to be altered when using Angular or Vue for example but should be easy enough to achieve

In `src/client/.env`:

```bash
REACT_APP_API_HOST=http://localhost:5000/
```

In `src/client/.env.production`:

```bash
REACT_APP_API_HOST=/
```

This means if you use this variable, `process.env.REACT_APP_API_HOST`, in your app as I have in the file [`src/api/config.js`](https://github.com/sethreidnz/aspnet-core-spa/blob/master/src/client/src/api/config.js) the `REACT_APP_API_HOST` value is going to be `http://localhost:5000/` when running `npm start` and will be the current host that is serving the app when its build using `npm run build`.

As I mentioned if you had development server at `https://my-development-server.azurewebsites.net`, you could get frontend developers to add the file `src/client/.env.local` with the following content and they wouldn't need to worry about the API project at all:

```bash
REACT_APP_API_HOST=https://my-development-server.azurewebsites.net/
```

### Enable CORS during development

In order to make this work in development we need to get around the [Cross Origin Resource Sharing (CORS)](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) restrictions which would mean that if you make an HTTP request from your client app at `http://localhost:3000` to the server at `http://localhost:5000` it won't work. However we want to make sure that in production we are secure and don't allow other domains to make requests to our server.

We can do this by adding the following CORS policy to the file [src/server/Startup.cs](https://github.com/sethreidnz/aspnet-core-spa/blob/master/src/server/Startup.cs#L29):

```csharp
services.AddCors(options => options.AddPolicy("AllowAll", policy => policy
.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader()));
```

This is defining a CORS policy to allow all origins for simplicity since we are only going to enable this when running in development mode. To do this you can add the following to [src/server/Startup.cs](https://github.com/sethreidnz/aspnet-core-spa/blob/master/src/server/Startup.cs#L42):

```csharp
if (env.IsDevelopment())
{
 app.UseDeveloperExceptionPage();
 app.UseCors("AllowAll"); // in development enable the AllowAll cors policy
}
else
{
 app.UseHsts();
}
```

See the full implementation in the [Github repository here](https://github.com/sethreidnz/aspnet-core-spa/blob/master/src/server/Startup.cs#L42)

### Use web.config reroute rules

The final piece of this implementation is using a `web.config` to achieve the following:

1. Static Assets - All requests for assets such as images, CSS and JavaScript are re-written to be served from the wwwroot folder
1. Correct MIME types for static assets - The correct MIME types are setup so that the various static assets are served correctly by IIS
1. Requests for the root of the site - If a request for the root of the site (e.g. https://my-spa-application.azurewebsites.net) the `wwwroot/index.html` is served
1. All requests that do not start with `/api/` are redirected to the `wwwroot/index.html` file in the server application
1. All requests that start with `/api/` are allowed to pass through to the ASP.NET application
1. Caching is disabled on the file `wwwroot/index.html` so that when we redeploy the new version of the file is served, along with the updated JavaScript and CSS files

The full web.config can be found in the repository [here](https://github.com/sethreidnz/aspnet-core-spa/blob/master/src/server/web.config) but I'll explain the key pieces.

#### Static Assets

The first re-write rule is the following:

```xml
<rule name="wwwroot-static" stopProcessing="true">
 <match url="([\S]+[.](html|htm|svg|js|css|png|gif|jpg|jpeg|ico))" />
 <conditions logicalGrouping="MatchAll">
 <add input="{HTTP_METHOD}" pattern="GET|HEAD" />
 </conditions>
 <action type="Rewrite" url="wwwroot/{R:1}" />
</rule>
```

This rule will catch all requests for the file types `html|htm|svg|js|css|png|gif|jpg|jpeg|ico` and reroute them to get them from the folder `wwwroot`. If you have other file types then you need to add them to this rule.

## Correct MIME types for static assets

The following section inside the `` section will add most of the common MIME types, extra MIME types such as video will need to be added here.

```xml
<handlers>
 <add name="StaticFileModuleHtml" path="*.htm*" verb="*" modules="StaticFileModule" resourceType="File" requireAccess="Read" />
 <add name="StaticFileModuleSvg" path="*.svg" verb="*" modules="StaticFileModule" resourceType="File" requireAccess="Read" />
 <add name="StaticFileModuleJs" path="*.js" verb="*" modules="StaticFileModule" resourceType="File" requireAccess="Read" />
 <add name="StaticFileModuleCss" path="*.css" verb="*" modules="StaticFileModule" resourceType="File" requireAccess="Read" />
 <add name="StaticFileModuleJpeg" path="*.jpeg" verb="*" modules="StaticFileModule" resourceType="File" requireAccess="Read" />
 <add name="StaticFileModuleJpg" path="*.jpg" verb="*" modules="StaticFileModule" resourceType="File" requireAccess="Read" />
 <add name="StaticFileModulePng" path="*.png" verb="*" modules="StaticFileModule" resourceType="File" requireAccess="Read" />
 <add name="StaticFileModuleGif" path="*.gif" verb="*" modules="StaticFileModule" resourceType="File" requireAccess="Read" />
 <add name="StaticFileModuleIco" path="*.ico" verb="*" modules="StaticFileModule" resourceType="File" requireAccess="Read" />
 <add name="aspNetCore" path="*" verb="*" modules="AspNetCoreModule" resourceType="Unspecified" />
</handlers>
```

#### Requests for the root of the site

To handle requests to the root of the site:

```xml
<rule name="empty-root-index" stopProcessing="true">
 <match url="^$" />
 <conditions logicalGrouping="MatchAll">
 <add input="{HTTP_METHOD}" pattern="GET|HEAD" />
 <add input="{QUERY_STRING}" pattern="^$|^lc=" />
 </conditions>
 <action type="Rewrite" url="wwwroot/index.html" />
</rule>
```

This will reroute the requests with or without a `/` to serve the `wwwroot/index.html`.

#### Handling Client Side Routes

Single page applications usually have routes that need to be handled by the frontend and not the server, for example `https://my-development-server.azurewebsites.net/my-client-route`. To do this we create a rule that will catch all requests that are not for a file or folder or don't start with `/api/` and pass the route onto the `wwwroot/index.html` like this:

```xml
<rule name="html5-routes" stopProcessing="true">
 <match url=".*" />
 <conditions logicalGrouping="MatchAll">
 <add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />
 <add input="{REQUEST_FILENAME}" matchType="IsDirectory" negate="true" />
 <add input="{REQUEST_URI}" pattern="^/api/" negate="true" />
 <add input="{HTTP_METHOD}" pattern="GET|HEAD" />
 </conditions>
 <action type="Rewrite" url="wwwroot/index.html" />
</rule>
```

The main thing to note here is the line where we negate the path `/api/`:

```xml
<add input="{REQUEST_URI}" pattern="^/api/" negate="true" />
```

If you would like to add other paths to let through then you would just add to that line, for example if you had a regular MVC controller to handle accounts at the path `/account` you would could update the line to be like this:

```xml
<add input="{REQUEST_URI}" pattern="^/api/|^/account/" negate="true" />
```

## Summary

I've used this approach in numerous applications and have found it to be really effective and extremely easy to setup. I really like how it means that the front-end and the back-end are loosely coupled, meaning that parts of the team who work on each don't need to worry about how to setup and run the parts they aren't working on.

If you want to try running this locally or test this out and deploy it to Azure then check out the [detailed README here](https://github.com/sethreidnz/aspnet-core-spa), or have a look at the various ways you can deploy to Azure [here](https://docs.microsoft.com/en-us/aspnet/core/host-and-deploy/azure-apps/?view=aspnetcore-2.1).

## More Reading

- [Deploying ASPNET Core Apps with VSTS](https://sethreid.co.nz/dotnet-core-vsts-hosted-agents/)
- [Deploying a Create React App project to Azure with VSTS Build and Release](https://sethreid.co.nz/deploying-create-react-app-project-azure-vsts-build-release/)

I'm a huge fan of coding standards, but I'm not a big fan of having to enforce them myself. This article is here to show you how to setup automatic code analysis using the new Rosyln anaysers and the ports of the classic StyleCop rule sets. If you want to see a basic .NET application with all this setup then you can [find it here](https://github.com/sethreidnz/dotnet-code-analysis).

> _NOTE:_ This will work with both Visual Studio and Visual Studio code, although I haven't been able to figure out how to get live analysis in Visual Studio code yet... But it still works on building the project

As a team of people working on software the easiest thing to do is to come up with a reasonable set of standards and use your build tools to enforce it. That way code reviewers don't have to waste time nit-picking and everyone can be happy that the code and style is consistent.

That is where style rules and code analysis comes in. Historically when using .NET you could use the 300+ rules shipped as part of _FxCop_ (FxCop is an application that analyses managed code assemblies. Don't worry if you don't know what this is as they freely admit "to many people 'FxCop' means nothing"). But as explained [here](https://github.com/dotnet/roslyn-analyzers/blob/master/docs/FxCopPort/Porting%20FxCop%20Rules%20to%20Roslyn.md) with the release of the new [open source Roslyn compiler](https://github.com/dotnet/roslyn) the team have ported much of what is useful from FxCop into individual packages that you can consume from your application, including in .NET Core.

## What do you get?

In a nutshell you can install a few packages to your project and automatically get live analysis and build time analysis to tell you and your team if they are breaking set guidelines.

Having ported a lot of the style rules from the old StyleCop way of doing things they have made other really useful improvements which mean:

- A significantly tightened set of rules, removing many obsolete ones, and adding new ones for things such as `async` and `ImmutableCollections`.
- Live analysis as you type in Visual Studio.
- Roslyn based analysers can ship with 'fixers' meaning, where possible you can use the context menu to automatically fix errors instead of manually fixing them.
- Rules that are specific to an APIs will reside in packages that ship with the API automatically, meaning you don't have to find and download it yourself.
- Rules that don't relate to a specific API, but are more general guidelines are now grouped by the purpose they serve. For example, some rules might help API authors produce consistent public APIs, but those rules might not make sense for test assemblies.

## How to set it up

I'm going to focus on how you would set up a .NET core project, but this would be the same for .NET framework in https://sethreid.co.nz/wp/wp-admin/themes.phpprinciple except some of the details about how to install packages might be a little different.

The first thing you need to do to get the basic style rules added is add the following packages to your .csproj file (or install them through the Nuget Package Manager):

```xml
 <DotNetCliToolReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Tools" Version="2.0.1" />
 <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="1.1.0" />
 <PackageReference Include="StyleCop.Analyzers" Version="1.0.2" />
 <PackageReference Include="System.Runtime.Analyzers" Version="1.1.0" />
 <PackageReference Include="System.Runtime.InteropServices.Analyzers" Version="1.1.0" />
 <PackageReference Include="System.Security.Cryptography.Hashing.Algorithms.Analyzers" Version="1.1.0" />
 <PackageReference Include="Desktop.Analyzers" Version="1.1.0" />
```

This might seem like a lot of packages but as mentioned earlier all the rules are split up into packages for APIs they relate to. This set is pretty basic and I would start with these and see what rules you don't like and you can disable them.

If you loaded up a .NET WebAPI project with these installed you'd probably start seeing squigly lines like this:

<a
 href="http://sethreid.co.nz/how-to-setup-code-analysis-dotnet/warningswithanalyser/"
 rel="attachment wp-att-352"
>
 <img
 class="alignnone size-large wp-image-352"
 src="https://sethreid.co.nz/content/uploads/2017/12/WarningsWithAnalyser-1024x461.png"
 alt="Warnings With Analyser"
 width="1024"
 height="461"
 />
</a>

This particular rule I don't like and now I can show you how to disable rules using a rule set.

## Disabling rules and treating warnings as build errors

To disable rules you need to create a `.ruleset` file and reference it in your `.csproj` file. A Ruleset file is just a specific XML file that lets to determine which rules from which analyser sets you want to disable or modify. For example here is one I use:

```xml
<?xml version="1.0" encoding="utf-8"?>
<RuleSet Name="SmartRetail" Description=" " ToolsVersion="10.0">
 <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.Analyzers">
 <Rule Id="SA1101" Action="None" />
 <Rule Id="SA1133" Action="None" />
 <Rule Id="SA1200" Action="None" />
 <Rule Id="SA1309" Action="None" />
 <Rule Id="SA1402" Action="None" />
 <Rule Id="SA1611" Action="None" />
 <Rule Id="SA1615" Action="None" />
 <Rule Id="SA1633" Action="None" />
 <Rule Id="SA1649" Action="None" />
 <Rule Id="SA1652" Action="None" />
 </Rules>
 <Rules AnalyzerId="Microsoft.Usage" RuleNamespace="Microsoft.Usage">
 <Rule Id="CA2235" Action="None" />
 </Rules>
</RuleSet>
```

Unforunatley the rules don't have nice names but you can see the code in the warning in Visual Studio as in the above screen capture. For example the rule i above `SA1200` I have disabled by adding the line ``to the`StyleCop.Analyzers` section.

Now to use this you can add a new PropertyGroup element to your projects `.csproj` file like this:

```xml
<PropertyGroup>
 <TreatWarningsAsErrors>True</TreatWarningsAsErrors>
 <TreatSpecificWarningsAsErrors />
 <CodeAnalysisRuleSet>..\DotnetCodeAnalysis.ruleset</CodeAnalysisRuleSet>
 </PropertyGroup>
```

The above code is first defining where to find your <code>.ruleset</code> file and then there are two lines that are needed to tell the compiler to treat any style warnings as errors, which will break the build.

That is all you need to get going with some basic code analysis on your .NET project! This also works using Visual Studio

## Automatically fixing issues

Just to highlight how useful this is here is a screenshot of how you can not only catch the errors, but in most cases you can let Visual Studio automatically fix them for you too!

![Visual studio showing the context menu for fixing roslyn errors automatically](/content/FixErrorAutomatically-1024x285.png)

You can just click on the option to fix the error and you're done!

## Example application

I've created a [sample application](https://github.com/sethreidnz/dotnet-code-analysis) that you can look at to see the full setup described.

[Dotnet Code Analysis Sample](https://github.com/sethreidnz/dotnet-code-analysis)

I believe that anyone can learn the basics of software and technology. I grew up with my Dad using linux as a physicist, and my older brother creating games in QuickBASIC like snake. I loved **using** computers. I played the odd game, but wasn't a gamer. I would search the internet for music I loved. I used Power Tab to learn guitar riffs. I was in the generation that was involved in chat rooms with strangers and MSN Messenger. However, I never had even the slightest ambition of getting into programming or technology as a career.

I've been meaning to write an something about this for some time, and when I came across all the awesome stories in reply to this tweet I decided I finally would.

<StaticTweet id="887688092710088704" />

The thing I took away was that there are a lot of people like me. People who didn't necessarily get into tech as a lifelong passion, rather discovering it later in life, sometimes by accident.

<StaticTweet id="888117329132797953" />

The best thing about this Tweet is I only just noticed the typo saying "live my job" and it doesn't matter. It's so true!

Software development is skill that seems like magic to many people. I often hear "I'm no good at computers" and "I could never do that". I'm not a mind reader, and I don't pretend to be. But I feel like this may be similar to many people saying that they are "no good at maths". Really, I believe many people have just been socialized into **thinking** they can't. Or they believe it's something that people are inherently good at, and they aren't one of **those people**.

## This is not true

You only have to read thread in the above tweet to see this. I'm hoping we can and are changing this perspective by changing the way that we talk about tech.

When speaking at [my first conference](https://sethreid.co.nz/jumping-feet-first-first-conference-talk) I met [Robert Pearce](https://twitter.com/RobertWPearce) who did a great talk called [Behavior and Your Team](https://www.youtube.com/watch?v=tkdT41EMzbc&feature=youtu.be) about some of the negative attitudes that pervade our discourse online in the tech community. Mean tweets, angry articles, and an all too common tenancy to mock people's decisions of technologies, libraries or some other thing. Rather than offering them help, support or guidance.

An example of this is a series of Tweets by Sebastian McKenzie (who wrote the now world famous [Babel](https://babeljs.io)) where he explained why he probably wouldn't do open source again:

<StaticTweet id="879285562921889792" />
<StaticTweet id="879287638104178688" />
<StaticTweet id="879287830740164608" />

This is sad because he is a very talented developer and this project quite literally changed the landscape of web development forever. It pushed JavaScript (the language that the your browser uses) forward and inspired a whole new set of people to get involved in the community. But even the people who decide how JavaScript works (TC39 committee) and browser company developers were being disparaging!

## Everyone can do it

Everyone is good enough. You have what it takes. You are smart enough. You can contribute. And guess what? Not everyone in tech is a programmer. Not everyone in tech is a geek. Not everyone in tech is a hacker. Not everyone in tech needs to write the next killer app. The range of skills and personalities needed among different companies and industries is almost limitless. At a previous employer we had whole areas of the business that I didn't even know much about, building software for huge companies in languages I'm not even interested in learning.

And that is OK.

This goes further that getting into technology as a career. For example (and Mum I hope you are reading this) my Mum works at a library in my home town of [Christchurch, New Zealand](https://www.google.co.nz/maps/place/Christchurch/@-41.0745566,169.817073,5.75z/data=!4m5!3m4!1s0x6d318a24ecc046e5:0x501bfb7ef04fa8a8!8m2!3d-43.5344944!4d172.6370957). I've heard her imply that she doesn't know anything about technology and that she struggles... So do I! I just got a new MacBook Pro for work, and I feel like I'm starting again! But it is ironic that I have heard her talk about her interactions helping people with their technology problems - which prove she is a local technology guru!
I'm not saying that no one should ever be constructively critical of anyone else, because otherwise how would we improve? But we want more people to be engaged in **creation** and not just **consumption** of technology. We need to open the doors, open our minds and give them our knowledge, time and patience.

Because I know plenty of people have done that for me and **I thank you**.

@babeljs They're still building the same stuff, just not for you.

@babeljs I don't think I can do open source ever again. We built @yarnpkg in private and then open sourced. Quickly after I lost all motivation.

@babeljs @yarnpkg I remember Babel being attacked early on by people on TC39 and members of the browser teams.

@babeljs @yarnpkg I don't just mean "Babel sucks" I mean "Babel was written by incompetent developers".

Friends, what is your tweet-sized tech origin story? Mine is: while 19 &amp; living in Brazil, a friend said I should try CS. I did, loved it!

@jergason @TheLarkInn I was a struggling musician. I realised I didn't want to be broke anymore and I didn't want to teach. I retrained. Now I live my job so much


It's almost guaranteed that when I tell people what I do for a living they will ask something like the following:

> Do you think that A.I. is going to take over the world?

While the question comes in many forms, I think that this cuts to the heart of it. I think we **should** be worried about how and what artificial intelligence is going to be used for. Although, I firmly believe the solutions are social and cultural, as with most problems we deal with in society.

Yes the technology is new. Yes some of it might feel creepy. But let's take a deep breath, step back for a second, and think:

> Who's building these things? People.

## Technology doesn't kill people, people do

Technology almost always has the potential positive **and** negative outcomes. To downplay or ignore this requires ignoring huge swathes of history.

A great example is New Zealand's most famous Physicist Earnest Rutherford's work on radioactivity and nature of the atom. You could argue that this work almost inevitably lead to one of the most destructive man made creations of all time: the atomic bomb. Yet we haven't destroyed the planet (yet). This isn't to say we won't, but I'm simply pointing out that all technology and science is inherently neutral in outcomes until humans put it to work. I think Rutherford himself said it best:

> "Those who do not study history will relive it. Talk softly now. I have been engaged in experiments, which suggest that the atom can be artificially disintegrated. If it is true, it is of far greater importance than a war." - Earnest Rutherford 1919

I'm not an expert on international affairs and nuclear disarmament so I'm not going to get into how we avoid that particular catastrophe, but I see artificial intelligence technology in a similar light. His discoveries lead to many good things too and it's what we do with it that matters. Of course there are already many issues with how A.I. is being used already but more on that shortly.

## Understanding where we are right now

One thing many alarmists don't seem to appreciate is how primitive the A.I.'s that we have now really are. Note that I say A.I.'s with an **s**. I make this distinction because the term **intelligence** is very broad, and can paint the wrong picture. We have many different and distinct versions of A.I. making up a host of loosely connected A.I.'s. But these aren't really "intelligence" or at least not yet. Most of them are essentially computer programming models for doing applied statistics and are used to make decisions based on certain data sets.

A.I. algorithms fall into two broad categories, supervised and non-supervised. The vast majority of A.I. applications are supervised,. Without getting into the technical details this means that there is a human involved in labeling and selecting the data that is important for the prediction that you are trying to make. There isn't really any "intelligence" in the way that people traditionally think of it.

For example you have the [Public Safety Assessment](http://www.arnoldfoundation.org/initiative/criminal-justice/crime-prevention/public-safety-assessment) algorithm being used across the United States. The system uses data from across the country to determine, based on specific indicators, the chances of a person committing a crime or not returning to court while on bail. This has now replaced the money based bail system in New Jersey, and is an example of using statistical modelling on large scale data sets that produces a sort of "intelligence" that the human brain is simply not able to muster.

We also have more familiar examples of this sort of technology including the various algorithms that are behind your Facebook feed. These determine which posts you see based on the behaviour of the current user, as well as behaviour of *similar* users. This is also how Google's search ranking works, as you would know if you ever tried to Google similar things on other people's machines and got difference results.

All this to say that while these things are really useful and we can call them "intelligence" it is no where near the idea of General Intelligence (ala a human like consciousness) which requires transferable and adaptable ways to make decisions in unrelated arenas. Not to mention that the decisions reached by these A.I.'s are only as good as the data that they are trained on, as so hilariously highlighted by the [accidentally racist Twitter Bot](https://en.wikipedia.org/wiki/Tay_(bot)). If you think really hard about it you might imagine you could glue these different A.I.'s together and form a super A.I. But you would then require some sort of algorithm that determines which of the other A.I.'s to use in certain circumstances. Inception.

But technological barriers can always be overcome and I'm not here to tell you it's not possible. I'm here to tell you how we could and probably will avoid being enslaved by our robot overlords relatively easily.

## Ethics and professionalizing I.T.

Most people who ask me about the impending A.I. doom are very surprised to hear that unlike other professions such as Medicine or Law we really don't have any overarching professional body or core of agreed ethical guidelines. There are I.T. professional bodies that do certifications and other training but it's not like passing the bar or getting your medical license. For example in New Zealand it costs money to be part of some of these groups and their focus (at least from the outside) is not ethics, and more importantly no one has to join to write software for a living.

This breakdown of dividing lines and barriers of entry to the industry has in some ways been the great strength of the software and internet age. This has allowed all sorts of people and ideas to flourish. It goes hand in hand with with net neutrality and the fact that everyone has a voice in this new connect world we live in.

A downside is that companies like Uber and Facebook generally don't care about ethics until there is a headline that might hurt their stock price. Does anyone remember Facebook talking about making sure that news wasn't "fake" when the initially rolled out their Instant Articles feature? That didn't happen until after their was an U.S. election result that shocked everyone and they had the finger pointed at them, along with others. I don't mean to just focus Facebook either. Microsoft, Amazon, Google, and others are actively working on ["democratizing A.I."](https://news.microsoft.com/features/democratizing-ai/) There is a real risk that things could go wrong, whether on purpose or not.

The industry just hasn't been around long enough and it changes so fast that nothing like what's happened to other professions has happened yet. But we need it.

## How would this help?

Simply put if we had some form of overarching ethical guidelines about what and how we build software then we could easily make sure of one thing: **Don't build an A.I. that is capable of stopping us from turning it off**. My thoughts on ethics go further than this [as I've written before](https://sethreid.co.nz/humane-tech-we-are-the-reason-it-will-get-better/) but if you think about it just a little bit, it's clear we can use ethical and societal mechanisms to avoid The Singularity.

Forget The Terminator and West World type scenarios, there are just **so many** technological advances required between where we are now and that future. It's not like we can get from where we are now to SkyNet without **real people** being involved in how and why we build the systems themselves.

The one thing I really don't know is how exactly we are going to make this professionalization happen beyond doing what myself and other people, such as [Tristan Harris](http://www.tristanharris.com/) and [Anil Dash](http://anildash.com/), who have come before me are trying to do: **talk about it**. There are a number of different groups around the world, such as [The New York Tech Alliance](https://nytech.org/about/overview) among others, trying to do this work. This is great but currently it's hard, even for someone like me who is passionate about it, to figure out how to get involved or where to start.

But things are moving in the right direction, we see companies like Uber [being constantly put under pressure](https://www.buzzfeed.com/priya/uber-exec-accused-of-ignoring-complaints-i-take-all) for their ethics and the way they run their business. Another small example is the rise of the mind share that accessibility of software for people with disabilities is getting among developers. I think this is all part of a move toward a place where one of the key aspects of designing software will be [designing it with ethics](http://www.tristanharris.com/the-need-for-a-new-design-ethics/).

If we can do that I don't think we have to worry about the extreme case of accidentally creating a singularity. Or the more reasonable case of A.I. causing perverse outcomes for individuals and society society as a whole. Either way, this technology is already here. We can blindly bumble our way through or choose to go into it with our eyes open, with sound ethical and moral principles that we all agree on.

Lets make this happen.

I often reflect on my interesting position of being an avid fan of type systems and precompiled production code, while primarily being a JavaScript developer. Especially as the ever changing landscape of the web development world keeps morphing slowly into something that is completely different... But somewhat familiar.

I recently got involved in a discussion on Twitter about Facebook's type checker [Flow](https://flow.org/) and how it could be improved. This kicked off a thread where Daniel Perez Alvarez (@unindented) chimed in making a request for the late comer (Flow) to collaborate more with the more established [TypeScript](https://www.typescriptlang.org/). TypeScript's type system is not only extremely powerful, many library authors have already made great efforts to define the types in their APIs with [Definitely Typed](http://definitelytyped.org/), even if they don't even use TypeScript. Problem is now these same people are having to duplicate work creating Flow definitions too.

This brings me to the title of this post and why I think this whole thing is a little bit funny, especially as a fan of C# and other statically typed languages... We've been here before.

### Object oriented?

I remember when the murmur of classes coming to JavaScript started there was a lot of dissidence. I even went to a talk that was decrying the inclusion of such heresy against the [prototype model](https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Objects/Object_prototypes) underpinning the language. JavaScript is JavaScript and we don't need any of this object oriented non-sense.

But now thanks to [Babel](https://babeljs.io) and various libraries like [React](https://facebook.github.io/react/), [Angular](https://angular.io/) and [Ember](https://www.emberjs.com/) they have become accepted parts of the language. Even if it's just syntactic sugar and the implementation is a little flawed (who hasn't had problems with `this` in class?).

### Compiled Vs interpreted?

This brings me to compiled vs interpreted languages, JavaScript being the later. Interestingly a lot of modern JavaScript development is in this weird middle ground where it's accepted as best practice to use a pre-compiler like Babel, or a super set language like Typescript, but your code is still interpreted in the browser. So now front-end projects have build servers and "production" vs "development" builds. Not to mention the imminent arrival of [Web Assembly](http://webassembly.org/) which is literally a compile target for the web.

I could have sworn I've heard many people scorn the complexity and hassle of compiled languages...

### Type systems just get in my way!

Getting back to the Twitter discussion above, I know many people who have said that they "don't believe in type systems" or "it just gets in my way" or "it's too hard for beginners" and various other argument against type systems. But there has been a sea-change in this attitude toward static type checking and in my opinion this is step forward.

Type systems are not only great for avoiding simple errors and reducing the amount of unit testing you need to do as a result, they also serve as a form of "documentation as code". You can read the code and know the shape of data going in and out of functions. You can see what available methods are on objects and classes. If you use a [good text editor](https://code.visualstudio.com/) or IDE you get autocomplete on properties and methods, safer refactoring and type safety warnings. In my opinion adding types to any non-trivial code base is a major win with very little downside.

## Prediction

This brings me to something I've long predicted could happen based on this trend of JavaScript taking the best parts of languages that it's developers love outside of JavaScript. **One day JavaScript will have an optional type system like TypeScript and Flow do**. The creator of JavaScript Brendan Eich gave me some evidence that we are getting closer to this coming true:

<StaticTweet id="885312100767223808" />

This is already in fact [in the spec (fifth bullet)](https://www.ecma-international.org/ecma-262/7.0/index.html#sec-forbidden-extensions). What it means is that the browser implementations of JavaScript aren't allowed to extend the language in a way that would get in the way of implementing the type annotation syntax used by both TypeScript and Flow. For example:

```javascript
function greeter(person: string) {
 return "Hello, " + person;
}
```

Where the **type** of the parameter `person` is `string` which is annotated by using the syntax `person: string`.

This means is that TC39 (the committee that decides on the JavaScript spec) have safeguarded against browser vendors making extensions to the language in their implementation that would get in the way of them including a similar syntax in later specifications...

Why do I think this is funny? I swear a few years ago people were bagging on type systems in JavaScript... Maybe I'm just being hopeful but we'll see.

@drosenwasser @TheLarkInn @unindented @calebmer @BrendanEich @flowtype Would be nice to see flowtype support ts type definitions

@LordHanson @drosenwasser @TheLarkInn @unindented @calebmer @flowtype TC39 agenda item, based on reserving : after declarator name in declarations.


Azure Resource Manager (ARM) templates let you deploy and configure various Azure resources using a JSON file with a particular schema. Most of this schema is pretty easy to figure out from their documentation or by creating the resources in the Azure Portal and then using the "Automated Script" section of the resource group to look at what and how things were deployed.

One thing I haven't found great documentation on are Azure Web App Site Extensions. For example if I wanted to install the [Composer Extension](https://www.siteextensions.net/packages/ComposerExtension/) automatically when I deployed my web app. Here is what you need to know.

## The ARM Template JSON

You need to add a resource to the resource section of your Azure Web App that has the **site extension name**. Just to make it clear in your ARM template you have a **top level** resources array and then **within your Web App** you can have another resources array. It is the array within the target web app you should add the following:

```json
{
  "apiVersion": "2015-08-01",
  "name": "name-of-extension",
  "type": "siteextensions",
  "dependsOn": ["the-name-of-your-webapp"]
}
```

You need to replace **the-name-of-your-webapp** and **name-of-extension** with the appropriate values.

But how do I know the **name-of-extension** value? You look up the extension on the [Site Extension Gallery](https://www.siteextensions.net) and take the value that is in the URL on its home page. For example the Composer extension has the URL:

[https://www.siteextensions.net/packages/ComposerExtension/](https://www.siteextensions.net/packages/ComposerExtension/)

So the name is "ComposerExtension". An example of a web app with the composer:

```json
{
  "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "siteName": {
      "type": "string",
      "defaultValue": "[resourceGroup().name]"
    },
    "appServicePlan": {
      "type": "string",
      "allowedValues": ["Free", "Shared", "Basic", "Standard", "Premium"],
      "defaultValue": "Free"
    }
  },
  "variables": {
    "appServiceName": "[parameters('siteName')]",
    "appName": "[parameters('siteName')]",
    "configAppName": "[concat(parameters('siteName'), '/web')]"
  },
  "resources": [
    {
      "comments": "The App Service to host the Web App",
      "type": "Microsoft.Web/serverfarms",
      "sku": {
        "name": "[parameters('appServicePlan')]"
      },
      "kind": "app",
      "name": "[variables('appServiceName')]",
      "apiVersion": "2015-08-01",
      "location": "[resourceGroup().location]",
      "scale": null,
      "properties": {
        "name": "[variables('appServiceName')]",
        "numberOfWorkers": 0
      },
      "dependsOn": []
    },
    {
      "comments": "The Web App",
      "type": "Microsoft.Web/sites",
      "kind": "app",
      "name": "[variables('appName')]",
      "apiVersion": "2015-08-01",
      "location": "[resourceGroup().location]",
      "properties": {
        "name": "[variables('appName')]",
        "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', variables('appServiceName'))]"
      },
      "dependsOn": [
        "[resourceId('Microsoft.Web/serverfarms', variables('appServiceName'))]"
      ],
      "resources": [
        {
          "apiVersion": "2015-08-01",
          "name": "ComposerExtension",
          "type": "siteextensions",
          "dependsOn": ["[variables('appName')]"]
        }
      ]
    },
    {
      "comments": "The config for the Web App",
      "type": "Microsoft.Web/sites/config",
      "name": "[variables('configAppName')]",
      "apiVersion": "2015-08-01",
      "location": "[resourceGroup().location]",
      "scale": null,
      "properties": {
        "localMySqlEnabled": true,
        "numberOfWorkers": 1,
        "netFrameworkVersion": "v4.0",
        "phpVersion": "7.1",
        "virtualApplications": [
          {
            "virtualPath": "/",
            "physicalPath": "site\\wwwroot",
            "preloadEnabled": false,
            "virtualDirectories": null
          }
        ],
        "defaultDocuments": ["index.php"]
      },
      "dependsOn": ["[resourceId('Microsoft.Web/sites', variables('appName'))]"]
    }
  ]
}
```



I host a meet up in Christchurch called [AChristchurch Azure Evening Meetup](https://www.meetup.com/Christchurch-Azure-Evening-Meetup/) and this week we had a two great presenters [Akmal Fazleen](https://www.linkedin.com/in/akmalfazleen/) and Aurora Lin from [Jade Software](https://www.jadeworld.com/) talking about chat bots, Luis and Azure Machine Learning. The thing that was blew me away is that both the presenters were not "technical" people and weren't developers. Akmal is a business analyst and Aurora is a graduate intern and they spoke about their experiments building a chat bot that can help you buy insurance. This is the story of [TOBi the chat bot](http://insights.jadeworld.com/tobi).

## Fitting the pieces together

I think one thing Microsoft is doing well with many of their recent cloud tools is making them at different levels of abstraction for different audiences and purposes. You can see this with the when you compare the more raw [Bot Framework](https://dev.botframework.com/) to the "as a service" [Bot Service](https://azure.microsoft.com/en-us/services/bot-service/) offering. You also see it with the [choice between Flow, Logic Apps, Functions and WebJobs](https://docs.microsoft.com/en-us/azure/azure-functions/functions-compare-logic-apps-ms-flow-webjobs) which are all basically automated and managed ways to run pieces of logic or code. 

This is also how Akmal and Aurora and the rest of their team at Jade were able to develop their chat bot with very little coding.

## What does the chat bot do?

The chat bot is a live and you could try out yourself but it's just for demo... Don't expect the insurance to payout! But basically the concept is that the bot is able to understand certain intents from you as the user and initiate dialogs that will result in collecting information and in purchasing life insurance. If you'd like to try the chat bot out then visit the blog post [here on Jade's site](http://insights.jadeworld.com/tobi).

## How does it work?

What they have done is stitched together pieces that Microsoft provides you and its made up of three main parts.

### LUIS (Language Understanding Intelligent Service)

LUIS is a service that is provided by Microsoft and it allows you to "train" it to understand certain phrases or words and figure out the intent behind them as well as associated information that you need from your user. The process of training is done using the LUIS user interface to add certain "Utterances" (sentences, phrases, words etc), "Intents" behind the utterances and "Entities" which represent associated data you are collecting from the utterances such as "topic" or "category" for example. Basically LUIS acts as your interpreter for your user's input and you can train it up to understand the needs of your user's and your business.

![Example of LUIS's user interface](/content/luis-example-1024x793.png)

The user interface is simple and it requires no coding at all. One very cool feature is that it lets you look at phrases that have been received and you can continue to train the LUIS model based on the real input to your chat bot.

### The Bot Framework

Bot Framework is made up of a service and web interface to register your bot and configure it as well as some libraries written, in a few different programming languages, that provide you a few easy ways to create your chat bot's conversations with your users. This does require a little bit of coding but a lot of the pain is taken out of it. Now there is even the [Bot Service](https://azure.microsoft.com/en-us/services/bot-service/) which is another layer on top that manages the deployment and the hosting of the dialogues and chat bot code. The bot framework also has integrations with LUIS so that means that you can easily wire up various dialogues in your chat bot with the requests to the LUIS service and get back the intents and entities that it can determine. Using all this the team from Jade were able to make a chat bot that can guide a user through the questions needed to purchase life insurance. But they didn't want to stop there... They wanted to add an Amazon style "people who bought this also bought this" type of recommendations **after** the user bought life insurance.

### Azure Machine Learning

[Azure Machine Learning](https://azure.microsoft.com/en-us/services/machine-learning/) is a great example of taking something that implementing yourself can be quite complex, time consuming or infeasible if you don't have the technical knowledge or time to learn it. Machine learning is an umbrella term that describes the various techniques and methods using statistical modeling to make predictions and decisions based on datasets. For example you could use a machine learning algorithm to take historic car action sales data and make predictions on the about the price a car might sell for.

What Microsoft have done is pulled together a selection of the most useful machine learning algorithms used in the world today and created an easy to use user interface to create and build machine learning models.

![Screenshot of the Azure Machine Learning UI with a Binary Classification for direct marketing](/content/simple-scalable-cutting-edge-1024x576.jpeg)

Using this the team at Jade was able to use a [Two-Class Boosted Decision Tree](https://msdn.microsoft.com/en-us/library/azure/dn906025.aspx) algorithm to feed in data from a customer purchase database to create models that will help figure out what product to recommend to a user based on what they have just bought or have bought before.

## What does this mean for the future?

The main thing that really excites me is the idea that more people can get involved in the "techy" things that all businesses are doing or beginning to do. Not only are things like [Cognitive Services](https://azure.microsoft.com/en-us/services/cognitive-services/) democratizing machine learning and A.I. but things like Azure Machine learning and LUIS are democratizing it outside of your usual technical audience. I'm looking forward to seeing more collaboration than ever between the business people in organizations and I.T. creating innovative solutions using the technologies.


Lately I've been thinking a lot about how best to spend my time and where I want to end up in life. The more I explore this the more I've noticed that a lot of people get into businesses or careers for well-intentioned but potentially counterproductive reasons. Did you start that amazing startup idea because the world really needed it? Or was it chasing that million dollar exit with a hope of happiness at the other end? Did you decide to get into a certain career for money or prestige? Did it live up to the hype when you actually started the work? Is what you do for the majority of your time something you would choose to do for free?

One thing I've definitely come to value is my own mental and physical well-being. Like the helpful advice of airline attendants, you need to make sure you have your own oxygen mask on before your can save the world... or make the million dollar exit. If everything you do comes from a place of trying to get "over there" into a position of "success" then you'll always be striving and if you're not careful you'll miss the ride. Happiness now is worth a billion dollars at 60 and gratitude for the things and people in your life are priceless right now.

Don't get me wrong I'm not bagging on people who want to build great companies or pursue all consuming careers. I'm speaking from my own personal journey from a struggling musician to a software developer and now some sort of social crusader (who's still a struggling musician). I realised instead of chase money I'd much rather grind at a project to try to make our communities a better place for all of us. I'm happier spending all my weekends writing music and creating acoustic versions of classic hip hop songs even if I only ever play them to my friends at parties. At least I had fun while I was alive and I did it with the people I care about.

Here's a poem I wrote about this feeling:

<BlockQuote>
 Life gets in the way 
 And you think everyday 
 Of all of the things that you do 
 The friends that surround you 
 When love's all around you 
 And how precious those moments are too 
 But when we sit there in silence 
 Everyday should remind us 
 To tell everyone that it's true. 
 I've loved every moment 
 And I want you to know it 
 To my family and friend I love you. 
</BlockQuote>

This morning I was listening to an <a href="http://www.radionz.co.nz/national/programmes/sunday/audio/201835480/neil-pasricha-on-happiness">interview with Neil Pasricha talking about happiness</a>. I found that he was describing exactly what I'd stumbled across recently and it's helped me finally become happy within myself. Do it for you , do it for passion or do it to be part of something bigger than you.

Many people think that their circumstances or the things that happen to them or the way they are are the reason they are happy (or not happy). The second part has been shown to be true and around 50% of what makes a person happy or unhappy is genes. But another whopping <a href="https://projecthappiness.com/science-of-happiness/">40% can come from our own actions and self reflection</a>. When you couple this with research into <a href="https://en.wikipedia.org/wiki/Epigenetics">epigenetics</a> and how the exact same genes can express themselves differently it goes a long way to explain why average incomes in affluent countries have been rising but reported happiness levels have remained about the same. These external measures such as job title, salary, assets and even power are no replacement for simply being comfortable in your own skin and happy right now.

The ironic thing about all this is that I decided to start my degree in "Software and and I.T" at age 22 simply because I was sick and tired of being a poor musician, performing at the same dive bars playing songs I didn't like and slowly having all passion for music sucked out of me. I was lucky to have found a of love for building and helping others build software but it could have easily gone the other way. To add to that, now that I don't worry about how to pay the bills, I'm finding I'd rather spend my time writing or playing music than on side hussles with the sole aim of getting rich.

What I'm saying is that every now and then try to take a some time out of your busy life and think about those things you see others doing and bemoan "I wish I had the time to do that too". Because you do, you can and you should. I encourage you to go for the things you are passionate about and find a way to make it work.

I agree with what Ed Sheeran said in the live (and 1,000,000 times better) version of his new song Eraser. "I wish that love was a currency and the whole world was wealthy."

<iframe width="560" height="315" src="https://www.youtube.com/embed/pb2fwx4O_Ks" frameBorder="0" allowFullScreen></iframe>

Creating change through creativity, technology and leading by example

Articles - Page 2 of 3

Building Create React App with Azure Devops YAML

Using multiple YAML build definitions in Azure Devops

Delivering single page apps with ASPNET Core in Azure

How to setup code analysis/linting for .NET (with Roslyn analysers)

Anyone can do it - Changing the way we talk about tech

Ethics and Artificial Intelligence

JavaScript you are funny - Thoughts and predictions

Adding a Site Extension to an Azure Web App in an ARM template deployment

Chat bots and machine learning for non-technical people

Pursuing a career or pursuing my passion? Can I do both?