My Current Software Development Tool-belt

My Current Software Development Tool-belt / workflow (zulucoda)

I haven’t done this before where I post about what is currently in my development tool-belt. Within these last couple years of React development from 2016 to now, I’ve grown a lot, and I’ve worked with great tools, coding techniques and different patterns. You may check out this article where I explore patterns for migrating a legacy SPAs to React.

My mission with this blog post is to show you my current development tool-belt for creating a new web application:

  • What core technology do I use and why?
  • What packages do I use and why?
  • How do I structure my code and why?

Starting with the Core Technology
My coding core technology is JavaScript.
Why JavaScript?
From 2005 to 2012 I use to build web applications (monoliths) using ASP.NET. In 2013 I made the switch to start separating my Back-end from my Front-end by using AngularJs for my Front-end. This switch gave me the ability to unit test my Front-end. The Back-end became a simple REST API that could be consumed by other applications as well, example Mobile Apps. It was also far more comfortable to code Web Apps in AngularJS using JavaScript, and I was hooked on JavaScript for everything. It was around this time I also started experimenting with nodejs (However, that’s for another blog post in the future. Back to my current development tool-belt)

So fast-forward to now; JavaScript keeps getting better and better, the community keeps creating amazing open source technologies for us to use. The ECMAScript Wizards keep adding new features and keep making JavaScript great.

My web-app core technology is React.
Why React?
I’ve invested in books, front-end masters courses and many many more hours spent on blogs and tutorials. I’ve also been using it at work since 2017 till now. I know the ins and outs of React quite well, and with React you’ve got React Native as well which allows you to do mobile apps. At the moment React is my default front-end tool, and until something comes along that’s going to dethrone React as React did with Angularjs then I might consider it, but for now, its all React for me.

Okay, great so at this point, I am using JavaScript and React.
When I start a new project, I use create-react-app.

create-react-app is a React boilerplate for more info go to https://github.com/facebook/create-react-app

$ npx create-react-app zulucoda-tool-belt-app --typescript

Why I use create-react-app?
I use it for everything. When I need to create a prototype to verify a package or feature quickly. By default it has all the basics you need:

Now that I have my core and project created, What packages do I use and why?

I am separating these into production dependencies (packages needed by the web-app to run in production) and development dependencies (excellent packages which make my development workflow superb)

Production Dependencies
Redux for State Management – https://github.com/reduxjs/redux & https://github.com/reduxjs/react-redux
Why Redux?
Once you understand the Redux architecture you, always want to create an application using this architecture. more info, please see how I use redux on migrating a legacy SPA.

$ yarn add redux react-redux

Redux-Sagas for Side Effects/Middleware – https://github.com/redux-saga/redux-saga
Why Redux-Sagas?
I use to use Redux-Thunk for Redux side effects/middleware. However, a while back a colleague of mine Mateusz Bosek introduced me to Redux-Sagas, and the Redux-Sagas pattern is terrific. Check out this article where I used sagas for migrating a legacy SPA to React.

$ yarn add redux-saga

React-Intl for Internationalising – https://github.com/yahoo/react-intl
Why React-Intl?
Before moving to Dubai, UAE. This package would not be on the list because all applications I worked on in South Africa only supported the English language, therefore, there was no need for React-Intl. However, this was just a lazy design because what if we did want to support an additional language we would have to refactor the entire application. So right now any application I work with has React-Intl by default even if only one language is used, at the start. If I need to add additional language support, the application is ready to support that.

$ yarn add react-intl

Material-ui for UI (Layout, Theme and Styling Components) – https://github.com/mui-org/material-ui
Why Material-ui?
There’s a massive community behind this open source project. React components that implement Google’s Material Design.

$ yarn add @material-ui/core

Development Dependencies
Because I used create-react-app to set up my React development. I already have the following:

  • Jest – for unit testing. I update my package.json file by setting the unit test code coverage.
  • Typescript – for type checking (In 2019 you must add types to your code.)

Update package.json

"jest": {
    "coverageThreshold": {
      "global": {
        "branches": 100,
        "functions": 100,
        "lines": 100,
        "statements": 100
      }
   }
}

Other development dependencies that help me with my development workflow:

Enzyme – https://github.com/airbnb/enzyme
why Enzyme?
I use it for unit testing React components (the view). I test things like button clicks, trigger onChange events, etc… I aim to have to have 100% test coverage in my React applications. See this blog post on unit testing in React.

$ yarn add -D enzyme enzyme-adapter-react-16

Prettier – for code format. https://github.com/prettier/prettier
Why Prettier?
No one has time to format their code :D, therefore, let prettier format your code for you. Decide your format rules upfront and let prettier do all the work. I configure prettier with husky and lint-staged to automatically format every file I commit. Therefore all code committed to GitHub is formatted automatically by prettier.

$ yarn add -D prettier husky lint-staged

Setup in package.json file

  "lint-staged": {
    "*.{js,jsx,ts,tsx}": [
      "node_modules/.bin/prettier  --config .prettierrc --write",
      "git add"
    ]
  },
  "husky": {
    "hooks": {
      "pre-commit": "lint-staged"
    }
}

Create .prettierrc file

{
    "singleQuote": true,
    "trailingComma": "all"
}

Okay, so now that I covered my core, and my main production and development packages. Next on the list is the coding structure.
With this fantastic React development environment set up with these main packages, and unit test coverage setup. All is useless if the coding structure is not modular or lacks a good structure that can scale.

Folder structure

zulucoda-folder-structure
zulucoda-folder-structure

config folder
This is where I set up my root reducers, sagas, etc.

zulucoda-config-structure
zulucoda-config-structure

modules folder
The modules folder is where I create my features for my web-app. Each feature has a components, containers and pages folder. Regarding nesting, before I’ve had a situation where I went crazy with nesting components inside components, this resulted in a complex nesting and over time the structure became difficult to work use. So the rule I use now, is I don’t go past 1 level of nesting. This means in the parent components is on the same level as children components. At first, this seems weird over time, and I got used to it. The same rule applies to containers and pages.

zulucoda-modules-structure
zulucoda-modules-structure

shared folder
In the shared folder, I place all items which are common or used in multiple places. This also where I place the API interface as well. The same nesting rules apply for shared folder structure.

zulucoda-shared-structure
zulucoda-shared-structure

Summary
Currently, this is I what use and its working for me. However, this is not cast in stone; it’s like an evolving style guide. Additionally, the packages and patterns that I am using are working for me right now, once again when I come across a package or patterns which works better or easier, I evaluate it, try it out and then it gets added to my tool-belt.
Repo: https://github.com/zulucoda/zulucoda-tool-belt-app

Yet Another Reason Why You Should Migrate Your Current (Legacy) SPA to React

Hybrid app solution simple overview

So with this post, I am trying something different. I am just going to tell you about my experience thus far with taking an existing SPA created in Backbone + jQuery and migrating this SPA to React.

I am going to get straight into it, and therefore if you’re new to React, my suggestion would be to check out other blog posts as this will cover advanced topics.

Additionally, I know that many people have written articles & posted videos on such migration. However, when I was reading and watching those videos, I was still missing critical architectural info. So even though sample code and blog post example were made available to me, this still didn’t help me in what I needed to do.

Migration Planning Phase
After doing research, I presented a few ideas to my colleagues and Head of Development. There where two main ways of going about our migration:

  • Hybrid Solution
  • Complete Clean Refactor

Hybrid Solution
This would allow us to slowly migrate sections of our existing Legacy SPA over to React one feature at a time. The ability for React to run side by side with other JavaScript libraries/frameworks is a significant feature. This is something I completely missed, even though Facebook have always stressed this point about React’s abilities (more on this later).

Complete Clean Refactor
We start from the ground up and re-build everything. There’s a point in the life of a product where a complete clean refactor is not feasible. When you have a product that is successful and clients are happy. Yes, the underlying tech might be outdated, it might take longer to deliver new features and maybe its no-longer developer friendly.
Additionally, asking business just for a budget to refactor an existing product? It’s no wonder why business does not trust its tech people.

After presenting this information to the team, the Hybrid Solution was a clear winner.

Before joining the team, I had been working on a React SPA that used a NodeJs + Express API. I was working on both of these code bases. Additionally, we had a React Native application using the same API. Moreover, before that, I was working on an Angularjs (1.5) App. Therefore I had no Backbone experience. However, this would not be an issue.

So we had an idea that we should do a hybrid solution, but we didn’t know how we would do it? Therefore it was suggested that we start by prototyping this hybrid solution.

The Prototype Phase
This phase would last two weeks, and we would use the learning’s from this phase to create an architectural solution, which we will use going forward for our smooth react migration.

During this prototype phase, I tried many solutions to get React working side by side with the Legacy SPA. Going back to the statement above about React being able to run side by side with other JavaScript libraries, I completely missed this in the first week of prototyping. I had created a complex solution evolving an iframe which would run the React app in the iframe. Then I had built this custom middleware which would hide and show the iframe when navigating too and from the Legacy SPA App to the React App. At first, this was a neat solution. It looked great and worked well.

When I presented my solution to my colleagues, they were happy with the outcome. However, they challenged me to simplify the architecture and use Redux Architecture with Redux-Saga as middleware and making use of Redux-Saga side effects for rendering components onto the DOM. This would get rid of the iframe and simplify the middleware to dispatch actions to redux and sagas and make use of Backbone events. This way any new developer joining the project would not need to learn my custom middleware but use existing tech knowledge they know about Redux and Backbone.

The Final Architecture
I cannot post the actual code as that is company property. However, the beauty of these patterns I used during the prototype phase are so simple and straightforward that I have recreated them for this blog post.

Hybrid app solution detail view
Hybrid app solution detail view

React App

  • Redux
  • React-Redux
  • Redux-Sagas

Legacy SPA App

  • jQuery
  • Some JavaScript Library
  • React-Middleware – used for dispatching actions

So the Legacy SPA does not have a clue about React it just continues to run as it does currently. We have a React-middleware which dispatches actions from the Legacy SPA to Redux or Sagas.

Storing User Info in Redux
So example currently on our SPA when a User logs in, after login, the react-middleware dispatches an action with User login payload, this is sent to Redux and the User data is stored in our Redux store for use for by our React App.

Rendering/Mount React Component
This is probably one of the coolest things I learnt about React which is the possibility of rendering multiple components onto the DOM. Now I didn’t know React could do this. However, I recently learnt from a conference talk that this is how they use React at Facebook.

In our SPA we decided to use redux-sagas side-effects to also render components onto the DOM for us. Therefore, on the Legacy SPA, an action is dispatched with a DOM element ID. Then a saga listening to this action uses that element ID to render a component onto that DOM element using ReactDOM.render(). The great thing about this is we are respecting the Redux Architecture, by simple dispatching an action, this easy to understand even for new people joining our team.

Rendering/mount react component using sagas side effects pattern
Rendering/mount react component using sagas side effects pattern

Un-Rendering/Dismount React Component

un-rendering/dismount react component using sagas side effects pattern
un-rendering/dismount react component using sagas side effects pattern

Where are we now
We have just finished our first feature in React, and it is working great inside the Legacy SPA. We are about to start creating more new features using React rapidly. We will also start looking at converting existing functionality over to React. The remarkable thing about this Hybrid solution, is we are keeping business happy by delivering the features they want. We as developers have created a great developer experience for ourselves.

So you want to know what you should test when using React?

So you have been using React now for some time, and you want to know what you have to test, and If you have seen one of Brian Holt’s videos on FrontEndMaster on Introduction React and Redux. In this video, Brian says that at Netflix they do not have unit tests for their React components because they change so often. The problem with this statement is a new guy, or an inexperienced team might take this out context to say that if Netflix does not write unit tests for their React components why should we. My problem with this is these people can use this as an excuse. Also, we have to look at the capabilities here, Brian Holt is a super talented developer, and at Netflix, He is surrounded by the best of the best, so for them, it works because they are operating on another level (rockstar level lol ??).

I come from Angular 1.5 where it was straightforward what needed to be unit tested. We wrote unit tests for controllers, components, services, directives and custom modules. The view was tested with e2e tests using protractor plus. With these you could get very impressive test coverage, one project I worked on we had 100% test code coverage. However, that was Angular 1.5 days, and we have since moved on from that to React. Like I had with Angular 1.5, I want all my React applications to have excellent test coverage.

With all the React applications I have built thus far I have focused a lot on testing, and within each app, I have been tinkering with different approaches. Moreover, I think I have found a good approach which works well for most applications including enterprise.

3 Step RCV (Redux, Container, View) Testing Approach

To demonstrate this RCV testing approach, I will be using my react-tunes-player repo. Also, for Redux I use the ducks modular pattern.

Step 1: Test Redux (RCV)

  • Redux: Test all your reducers and actions. In fact, my suggestion would be to use TDD (Test Driven Development) for this. Testing your reducers and actions has nothing to do with React, at this stage. If you are coming from Angular 1.5, you can think of this as testing some custom modules which had nothing to with Angular.
  • Note: If you are building a React application my suggestion is always to use Redux for State management. React + Redux are made for each other.

Testing an action & reducer
Note: This test below is making sure that when the setTunes() action is dispatched to the reducer, the expected state should have the tunes array set with the tunes received from setTunes().

View on GitHub: react-tunes-player-reducer.spec.js

//file-name: react-tunes-player-reducer.spec.js

  describe("set tunes", () => {
    it("should return state with tunes set when setTunes action is dispatched", function() {
      const action = setTunes(tunes());

      const actual = ReactTunesPlayerReducer(stateBefore(), action);

      const expected = {
        ...stateBefore(),
        tunes: [...tunes()]
      };

      expect(actual).toEqual(expected);
    });
});

Step 2: Test the Container (RCV)

  • Test your container. You should still use TDD (Test Driven Development) for this. Here you are testing your connected component, basically testing the glue between Redux and Your React Component. The key functions are mapStateToProps and mapDispatchToProps.

Testing mapStateToProps
Note: These tests below make sure that we have mapped state with the props we want to pass down into our view.

View on GitHub: react-tunes-player-container.spec.js

//file-name: react-tunes-player-container.spec.js
it("should mapStateToProp tunes to _tunes", function() {
    expect(wrapper.node.props._tunes).toEqual(
      initialState.reactTunesPlayerReducer.tunes
    );
  });

  it("should mapStateToProp current to _current", function() {
    expect(wrapper.node.props._current).toEqual(
      initialState.reactTunesPlayerReducer.current
    );
  });

  it("should mapStateToProp player to _player", function() {
    expect(wrapper.node.props._player).toEqual(
      initialState.reactTunesPlayerReducer.player
    );
});

Testing mapDispatchToProps
Note: These tests below make sure that we have mapped our actions to the props we want to pass down into our view.

View on GitHub: react-tunes-player-container.spec.js

//file-name: react-tunes-player-container.spec.js

it("should mapDispatchToProps setTunes", function() {
    expect(wrapper.node.props.setNextTune()).toEqual(setNextTune());
  });

  it("should mapDispatchToProps setPreviousTune", function() {
    expect(wrapper.node.props.setPreviousTune()).toEqual(setPreviousTune());
  });

  it("should mapDispatchToProps setTunes", function() {
    expect(wrapper.node.props.setTunes()).toEqual(setTunes());
  });

  it("should mapDispatchToProps setCurrentTune", function() {
    expect(wrapper.node.props.setCurrentTune()).toEqual(setCurrentTune());
  });

  it("should mapDispatchToProps playCurrentTune", function() {
    expect(wrapper.node.props.playCurrentTune()).toEqual(playCurrentTune());
  });

  it("should mapDispatchToProps pauseCurrentTune", function() {
    expect(wrapper.node.props.pauseCurrentTune()).toEqual(pauseCurrentTune());
});

Step 3: Testing the View (RCV)
Test your view. This is the controversial part which guys like Brian Holt and many others have said not to waste your time testing this is because the view always changes. My suggestion is the following:

  • Newbie – New to React: Test everything in your view
  • Inexperienced Team – New to React: Test everything in your view
  • Everyone else: Depending what your component does:
    • Test all component methods like componentDidMount, componentWillReceiveProps and etc..
    • If your component renders differently according to state, test those different render states

Testing different render states, plus componentDidMount and componentWillReceiveProps

View on GitHub: react-tunes-player-view.spec.js

//file-name: react-tunes-player-view.spec.js

describe("when not rendered with tunes", () => {
    beforeEach(function() {
      wrapper = shallow();
    });

    it("should render React Tune Player View with warning message displayed", function() {
      expect(wrapper.contains("Warning! No tunes loaded in player.")).toBe(
        true
      );
    });

    describe("componentDidMount", () => {
      it("should NOT add event listener when tunes props is supplied", function() {
        spyOn(
          ReactTunesPlayerView.prototype,
          "componentDidMount"
        ).and.callThrough();

        wrapper = mount();

        expect(
          ReactTunesPlayerView.prototype.componentDidMount
        ).toHaveBeenCalledTimes(1);
        expect(wrapper.find(".warning-wrapper").length).toEqual(1);
      });
    });

    describe("componentWillReceiveProps", () => {
      it("should NOT call playCurrentTune when isPlaying is true", function() {
        wrapper = mount(

        );

        wrapper
          .instance()
          .componentWillReceiveProps({ _player: { isPlaying: true } });
        expect(playCurrentTuneMockFunc).toHaveBeenCalledTimes(0);
      });

      it("should NOT call pauseCurrentTuneMockFunc when isPlaying is false", function() {
        wrapper = mount(

        );

        wrapper
          .instance()
          .componentWillReceiveProps({ _player: { isPlaying: false } });
        expect(pauseCurrentTuneMockFunc).toHaveBeenCalledTimes(0);
      });
    });
});

So if you are a Newbie or Inexperienced Team just test everything you will learn a lot about react, redux, enzyme, jest, shallow rendering and jsdom. However if you are NOT going to write tests for your view, the minimum you may check is if the React component still renders after making changes, and this can be done with enzyme using shallow rendering.

Minimum view tests – check if component renders without crashing

import React from 'react';
import { shallow } from 'enzyme';
import App from './App';

it('renders without crashing', () => {
  shallow(<App />);
});

Just like you, I am also always learning and getting better, so the above is my take at this moment in time. I will continue to tweak, experiment and improve. If there’s anything that you come across or a better method, please will you kindly share it? I am open to improvements.

@Brian Holt, thanks man for everything, it is because of you that I know React and Redux, thank you 🙂
Also shout-out to FrontEndMaster,
Also shout-out Anthony Accomazzo, Ari Lerner, Clay Allsopp, David Guttman, Tyler McGinnis, and Nate Murray these are guys that wrote Full Stack React.
Also shout-out to the creators of these excellent tools we use react, redux, enzyme, jest, create-react-app and many more.
Also shout-out to the guys that have written articles on testing React:

Automatically Deploy ASP.NET MVC, ASP.NET Web API, WCF Services or Generall Web Application to IIS

This is a follow up to my previous blog post on ‘Automated Deployments and Automation, in General, is Essential‘.

NO ONE should EVER deploy web applications manually! If you are currently doing this, please use the following script below and start deploying your web application automatically.

This is a PowerShell script, I must say I’m new to PowerShell, but I found it quite easy to learn and work with.

Gist: https://gist.github.com/zulucoda/81cd751f67a8cbba3605#file-create-web-application-in-iis-ps1

<# .SYNOPSIS
create-web-application - Automatic website creation.
.DESCRIPTION
Allows you to create a website and its ApplicationPool.
.NOTES
File Name : create-web-application.ps1
Author : Muzikayise Flynn Buthelezi - muzi@mfbproject.co.za
Copyright : MFBproject mfbproject.co.za
.EXAMPLE
PS D:\>create-web-application.ps1 -SiteName TESTSITE -Port 8080 -Environment PREPROD -Runtime v4.0 -Pipeline Classic
Creates a website named 'TESTSITE-PREPROD', listening on the TCP8080 port, responding to 'http://*' (default value). The associated ApplicationPool 'TESTSITE' running with the identity 'NetworkService' (default value), v4.0 .NET Framework managed runtime and 'Classic' managed pipeline mode.
#>
Param(
[Parameter(Mandatory=$true, HelpMessage="You must provide a display name for the website.")]
$SiteName = "testsite",
$Port = "8080",
#[ValidatePattern("([\w-]+\.)+[\w-]+(/[\w- ;,./?%&=]*)?")]
$HostName = "",
[ValidateSet("PROD", "PREPROD", "INTEG", "QUAL", "DEV")]
$Environment = "PROD",
[ValidateSet("0", "1", "2", "3", "4")]
$Identity = "2",
[ValidateSet("v1.1", "v2.0", "v4.0")]
[string]$Runtime = "v4.0",
[ValidateSet("Classic", "Integrated")]
[string]$Pipeline = "Integrated"
)
 
switch ($Identity)
{
0 {$FullIdentity = "LocalSystem"}
1 {$FullIdentity = "LocalService"}
2 {$FullIdentity = "NetworkService"}
3 {$FullIdentity = "SpecificUser"}
4 {$FullIdentity = "ApplicationPoolIdentity"}
}
 
function main(){
 
Write-Host "deploy web application"
 
if (LoadIIS7Module -eq $true) {
Write-Verbose "Add a New IIS 7.0 Web Site..."
Add-IIS7Website $SiteName $Port $HostName $Environment $Identity $Runtime $Pipeline
} else {
Write-Host "IIS7 WebAdministration Snapin or Module not found."
Write-Host "Please consult the Microsoft documentation for installing the IIS7 PowerShell cmdlets"
}
}
 
function Check-IfWebsiteExists($SiteName, $Environment){
$SiteName += "-$Environment"
if ((Test-Path -path "IIS:\Sites\$SiteName") -ne $false)
{
return $false
}
return $true
}
 
function LoadIIS7Module () {
$ModuleName = "WebAdministration"
$ModuleLoaded = $false
$LoadAsSnapin = $false
if ((Get-Module -ListAvailable |
ForEach-Object {$_.Name}) -contains $ModuleName) {
Import-Module $ModuleName
if ((Get-Module | ForEach-Object {$_.Name}) -contains $ModuleName) {
$ModuleLoaded = $true
} else {
$LoadAsSnapin = $true
}
}
elseif ((Get-Module | ForEach-Object {$_.Name}) -contains $ModuleName) {
$ModuleLoaded = $true
} else {
$LoadAsSnapin = $true
}
if ($LoadAsSnapin) {
if ((Get-PSSnapin -Registered |
ForEach-Object {$_.Name}) -contains $ModuleName) {
Add-PSSnapin $ModuleName
if ((Get-PSSnapin | ForEach-Object {$_.Name}) -contains $ModuleName) {
$ModuleLoaded = $true
}
}
elseif ((Get-PSSnapin | ForEach-Object {$_.Name}) -contains $ModuleName) {
$ModuleLoaded = $true
}
else {
$ModuleLoaded = $false
}
}
return $ModuleLoaded
}
 
function Read-Choice {
Param(
[System.String]$Message,
[Parameter(Mandatory=$true)]
[ValidateNotNullOrEmpty()]
[System.String[]]$Choices,
[System.Int32]$DefaultChoice = 1,
[System.String]$Title = [string]::Empty
)
[System.Management.Automation.Host.ChoiceDescription[]]$Poss = $Choices | ForEach-Object {
New-Object System.Management.Automation.Host.ChoiceDescription "&$($_)", "Sets $_ as an answer."
}
$Host.UI.PromptForChoice($Title, $Message, $Poss, $DefaultChoice)
}
 
function Select-IPAddress {
[cmdletbinding()]
Param(
[System.String]$ComputerName = 'localhost'
)
$IPs = Get-WmiObject -ComputerName $ComputerName -Class Win32_NetworkAdapterConfiguration -Filter "IPEnabled='True'" | ForEach-Object {
$_.IPAddress
} | Where-Object {
$_ -match "^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$"
}
 
if($IPs -is [array]){
Write-Host "`nServer $ComputerName uses these IP addresses:"
$IPs | ForEach-Object {$Id = 0} {Write-Host "${Id}: $_" -ForegroundColor Yellow; $Id++}
$IPs[(Read-Choice -Message "`nChoose an IP Address" -Choices (0..($Id - 1)) -DefaultChoice 0)]
}
else{$IPs}
}
 
function Add-IIS7Website($SiteName, $Port, $HostName, $Environment, $Identity, $Runtime, $Pipeline)
{
Write-Host "`n**********************************************************" -ForegroundColor Yellow
Write-Host "*`t`tAutomatic Website Creation" -ForegroundColor Yellow
Write-Host "*" -ForegroundColor Yellow
Write-Host "*" -ForegroundColor Yellow -nonewline; Write-Host " Parameters"
Write-Host "*" -ForegroundColor Yellow -nonewline; Write-Host " Website Name (-SiteName):`t`t" -nonewline; Write-Host "$SiteName" -ForegroundColor DarkGreen
Write-Host "*" -ForegroundColor Yellow -nonewline; Write-Host " Website Port (-Port):`t`t`t" -nonewline; Write-Host "$Port" -ForegroundColor DarkGreen
Write-Host "*" -ForegroundColor Yellow -nonewline; Write-Host " Website Hostname (-Hostname):`t`t" -nonewline; Write-Host "$HostName" -ForegroundColor DarkGreen
Write-Host "*" -ForegroundColor Yellow -nonewline; Write-Host " Website Environment (-Environment):`t" -nonewline; Write-Host "$Environment" -ForegroundColor DarkGreen
Write-Host "*" -ForegroundColor Yellow -nonewline; Write-Host " AppPool Identity (-Identity):`t`t" -nonewline; Write-Host "$FullIdentity ($Identity)" -ForegroundColor DarkGreen
Write-Host "*" -ForegroundColor Yellow -nonewline; Write-Host " Managed Runtime (-Runtime):`t`t" -nonewline; Write-Host "v$Runtime" -ForegroundColor DarkGreen
Write-Host "*" -ForegroundColor Yellow -nonewline; Write-Host " Managed Pipeline Mode (-Pipeline):`t" -nonewline; Write-Host "$Pipeline" -ForegroundColor DarkGreen
Write-Host "*" -ForegroundColor Yellow
Write-Host "**********************************************************" -ForegroundColor Yellow
if ((Check-IfWebsiteExists $SiteName $Environment) -eq $false) {
Write-Host "Website $SiteName already created!" -ForegroundColor Yellow
return $false
}
 
if ($Identity -eq "3") {
$AppPoolUser = Read-Host "`nPlease provide username for the ApplicationPool identity"
$AppPoolPwd = Read-Host "Please provide the password for '$AppPoolUser' user" -AsSecureString
}
 
$ChosenIP = Select-IPAddress
Write-Host "`nThe selected IP address is: $ChosenIP`n" -ForegroundColor DarkGreen
 
$SiteName += "-$Environment"
# Create the website directory
Write-Host "Creating application directory" -ForegroundColor Yellow
$WWWPath = "C:\inetpub\wwwroot"
$SitePath = "$WWWPath" + "\" + "$SiteName"
if (!(Test-Path $SitePath)) {
New-Item -ItemType Directory -Path $SitePath
}
 
# Creates the website logfiles directory
Write-Host "Creating application logfiles directory" -ForegroundColor Yellow
$LogsPath = "C:\inetpub\logs\LogFiles"
$SiteLogsPath = "$LogsPath" + "\" + "$SiteName"
if (!(Test-Path $SiteLogsPath)) {
New-Item -ItemType Directory -Path $SiteLogsPath
}
 
Import-Module "WebAdministration" -ErrorAction Stop
if ($Pipeline -eq "Integrated") {$PipelineMode = "0"} else {$PipelineMode = "1"}
 
# Creates the ApplicationPool
Write-Host "Creating website application pool" -ForegroundColor Yellow
New-WebAppPool –Name $SiteName -Force
Set-ItemProperty ("IIS:\AppPools\" + $SiteName) -Name processModel.identityType -Value $Identity
if ($Identity -eq "3") {
Set-ItemProperty ("IIS:\AppPools\" + $SiteName) -Name processModel.username -Value $AppPoolUser
Set-ItemProperty ("IIS:\AppPools\" + $SiteName) -Name processModel.password -Value $AppPoolPwd
}
Set-ItemProperty ("IIS:\AppPools\" + $SiteName) -Name managedRuntimeVersion -Value $Runtime
Set-ItemProperty ("IIS:\AppPools\" + $SiteName) -Name managedPipelineMode -Value $PipelineMode
 
# Creates the website
Write-Host "Creating website" -ForegroundColor Yellow
New-Website –Name $SiteName -Port $Port –HostHeader $HostName -IPAddress $ChosenIP -PhysicalPath $SitePath -ApplicationPool $SiteName -Force
Set-ItemProperty ("IIS:\Sites\" + $SiteName) -Name logfile.directory -Value $SiteLogsPath
 
Start-WebAppPool -Name $SiteName
Start-WebSite $SiteName
 
Write-Host "Website $SiteName created!" -ForegroundColor DarkGreen
}
 
main

Automated Deployments and Automation in General is Essential

It’s 02:00 in the morning, and I’ve been up for more than 14 hours now. I’m still manually deploying the latest services and application. It’s my first time deploying these services and apps because usually, other team members do it. We finish the deployment at 05:30 in the morning. We are all tired we go home and rest. We come in at around 11:00. There are some issues with various apps and services. We immediately start investigating. Deep into our investigation, we realise that missing steps caused most of the issues during the deployment. It’s simple things like updating the config or restarting the service. Surely there must be an easier way???

There is an easier way, and we all know what the easy way is. It’s automation. As suggested by Pragmatic Programmer book, we must take advantage of automation as much as possible. Yet we are manually deploying code, WHY? In my last team, the excuse was that we don’t have time to create automation scripts. OR Our suite of services and applications are too complicated to be automated. Fair enough, this might be true in the beginning, maybe there is no time to put together automation scripts because we are trying to complete functionality ASAP. So we let it slip. On our first deployment, we deploy everything within an hour; therefore, we convince ourselves that we don’t need automation.

STOP, don’t fall into this trap, you will pay for it later, just like we did at my previous company.

My suggestion is to set time aside for automation, add this as a practice during development, similar to unit testing or CI (Continuous Integration). What I’ve started doing is automating whatever task I repeatedly do. For example, the images throughout my blog have a filter added to them and are the same size. Also, they have been uploaded automatically to my server. I created a script, which does this.