Efficient Software Development with Jenkins X

What are the common problems in software development?

Software development is hard. It takes years to become a proficient developer, and the tech and the processes change so often. What was effective yesterday, is not necessarily effective today.

Multiple languages and frameworks

The number of languages we code in is increasing. While in the past, most developers would work in the same language throughout their whole career, today it is not uncommon for a developer to work on multiple projects written in different languages. We might work on a new project and code in Go while maintaining some other project written in Java. To be efficient, we need to install compilers, helper libraries, and quite a few other things.

Managing dependencies

No matter whether we write all the code in a single language or not, our applications will have different dependencies. One might need MySQL, while the other might use MongoDB as the data storage. We might also depend on applications developed by other teams working in parallel with us. No matter how good we become at writing mocks and stubs that replace those dependencies, eventually, we’ll need them running and accessible from our laptops. Historically, we’ve solved those problems by having a shared development environment, but that proved to be inefficient. Sharing development environments results is too much overhead. We’d need to coordinate changes, and those that we make would often break something and cause everyone to suffer. Instead, we need each developer to have the option to have its own environment where required dependencies for an application are running.

For the dependencies to be useful, we should run them in (almost) the same way we’re running them in production, which means we should deploy them to Kubernetes as well. For that, we can choose minikube or Docker Desktop if we prefer a local cluster, or get a segment (Namespace) of a remote cluster.

Managing multiple tools

Unfortunately, compilers and dependencies are not everything we need to develop efficiently; we also need tools. Today that means that we need Docker or kaniko to build container images. We need helm and kubectl to deploy applications to Kubernetes. We need skaffold that combines the process of building images with deployment. There are quite a few other tools specific to a language and a framework that would need to be installed and configured as well.

Even if we do set up all those things, we are still missing more. We need to be able to push and pull artifacts from the container registry, ChartMuseum, Nexus, or any other registry that might be in use in our organization.