What is Important

We will explore the different stages of a project and provide examples of what good could look like though sometimes even just doing good enough is fine.

All of the below statements are an opinionated example but there is no right answer. You will need to gauge what is acceptable and what is not acceptable.

The Beginning

While a software project is still in its early days the key is to make sure that changes can be made easily and quickly. We are still trying to decide which direction the application should head towards and there will constantly be changing to meet the users needs.

It is likely that we do not have many users and these users may expect it not to be perfect. If the application goes offline for a few hour during the day what will the impact be? If the impact is minimal maybe we do not need to have high availability.

We should focus on keeping things as simple as possible, reduce the dependencies and focus on what our users need.

The Middle

Once we have a market, we have many users but now it may become no longer acceptable to be offline for large periods of time. Then the priority may shift towards reliability and stability while accepting that doing a release maybe more time consuming, has to be done with more care and have more guard rails in place to ensure nothing breaks.

We are going to be collecting lots of data, running experiments and doing lots of activities outside of our core application. There will be a urge towards splitting the application up and having separate teams handle different domains. Be cautious that all choices may make some things easier but other things more difficult.

Once again we should still focus on keeping things as simple as possible, reduce the dependencies and focus on what our users need.

The End

Our application has possibly reached all the features it needed. Now it is just bug fixed and security updates. There maybe other options that users have to migrate towards so our set of challenges may move towards how do we offboard users.

Stages

Applications last different length of times but if we take a multi year project that is around for eight years. This series will look at the stages as follows:

• Prototype and Proof of Concept
• The First Release
• 100th Release
• 1,000th Release
• Beyond

Examples

This series will provide examples written in golang. Starting with something basic such as the following:

// main.go

package main

import (
	"fmt"
)

func main() {
	fmt.Println(name())
}

func name() string {
	return "Evolution"
}

// main_test.go

package main

import (
	"testing"
)

func TestNameIsEvolution(t *testing.T) {
	expected := "Evolution"
	actual := name()
	if expected != actual {
		t.Errorf("Expected %s but got %s", expected, actual)
	}
}

and allowing us to test, run and build the application using:

go test
go run main.go
go build -o evolution main.go

Code

You will be able to view a git repository for each part starting with the introduction. There will be one branch for each chapter as it progresses.

Github: part-1-introduction