Top 5 Programming Skills Worth Learning in 2021
Tags: functional, devops, docker, mobile
Published: 2021-04-10 20:34:40

2021 has already proven itself as another crazy year. It’s also another fantastic opportunity to learn new skills and expand on existing ones. In software development, stagnation is a sure-fire way to fall behind the curve. With new languages, technologies, best practices, and frameworks coming out more and more rapidly, this is the perfect opportunity to reevaluate where you want to go as a developer.

At the beginning of this year, I did just that. I wrote an article earlier this year about what I felt were the best languages to learn in 2021. With those, I felt that there was a nice mix for developers of any level and area of interest. However, they weren’t the languages for me to learn. Already in working with Python, Typescript, C#, and BASH, I thought about what I could do to help move my skills forward in other ways. After a lot of thought, I came up with a few programming skills that I believe are worth learning in 2021.

# 1. Functional Programming

This is a big one. Functional programming is a programming paradigm that revolves around the idea of moving data around, well, functionally! Instead of creating objects and callings methods on those objects, your data can be thought of as a stream, moving from function to function. It requires a different way of thinking about your programs. It's a lot easier to show it than to explain it.

Let's take a look at this Java code. It should be pretty familiar to anybody who has worked in an OOP language.

```java
String words= "Here,are,some,words";
words = words.replace(",", " ");
words = words.trim();
words = words.toUpperCase();
```

Here we are replacing the commas with spaces, trimming whitespace off the end, and then setting the whole thing to uppercase.

Now, let's look at the same example in Elixir, my favorite functional programming language.

```elixir
words = "Here,are,some,words"
	|> String.replace(",", " ")
	|> String.trim
	|> String.upcase
```

We are taking our stream and piping it into the replace function, which replaces commas with spaces. The output of that is piped into trim, which is then piped into upcase. Notice how words is assigned once, where as in our Java example, we declare it then reassign it three times. This is a key feature of Elixir. Data is immutable, meaning it cannot be changed. The string being passed into replace does not change but instead returns a new reference to a string. This new string is passed into trim, which returns a new one to upcase. Our variable words is only assigned once and our original input was never changed. This pattern of programming can help to create more robust and more maintainable software.

For those wanting to get started with functional programming, there is a lot to chose from! If you are on the JVM, you have Scala or Clojure to choose from. Scala might be easier, as it supports both OOP and functional programming paradigms. For those in the .NET side of the world, F# is a fantastic language. There is also a version of Clojure that runs on the .NET platform as well. My personal preference is Elixir, as its syntax is similar to that of Ruby’s but gives you the power of the BEAM, Erlang’s virtual machine.

You can find more information on Elixir at [https://elixir-lang.org/](https://elixir-lang.org/)

# 2. Swift, Kotlin, and Mobile Development

This one might strike some people as odd. However, I believe Swift has a place beyond just writing iOS apps. In 2015, Swift was published under the Apache 2.0 license, thus making it open source. As of now, it can be run on Mac and Linux and can run on Windows through the use of Docker.

Given this, Swift can be used to create more than just iPhone apps now. You can build APIs, command-line apps, and even do machine learning with it. Unfortunately, iOS is still restricted to Macs only, but it is a start.

The beauty in how easy the language is to write and use. It’s certainly C-inspired but *feels* like a modern language. It is nowhere near as clunky or verbose as Java. The same argument can be made for Kotlin, which is essentially aiming to fix the problems of Java while being a modern language. Kotlin is developed by JetBrains, so you know it’s treated as a first-class citizen in their IntelliJ platform. Kotlin can be used to build Android apps, which is excellent at but also building web apps using the Spring framework. It can be used alongside Java in existing projects, so adding it in is simple. Both of these languages blow past their predecessors in almost every way.

So why are these skills important? For one, mobile development is not going anywhere. In fact, I believe its need will continue to increase, due to the ever-growing number of systems that can now interact with phones. Apps now let you control your car, house, let you make payments, and so much more. Beyond that, both of these languages can now be used to build more kinds of applications. You essentially can build your mobile and backend in the same language now. If you learn Kotlin, you can even compile to JavaScript and use it on the web. And this isn’t even going into the amount of other smart appliances coming out. Watches, doorbells, and even washing machines are all getting smarter. Both Swift and Kotlin are great for building apps for these appliances or for building mobile apps to interface with them. These are fast, modern, and versatile languages with a lot to offer.

As a side note, Apple Silicon has already proven itself a beast and both of these languages have been shown to do very well on it. I believe we will see a wider implementation of ARM chips from all vendors eventually, so knowing these languages would be a great way to dive headfirst into these next-generation CPUs.

You can start with Swift at [https://swift.org/](https://swift.org/) and Kotlin at [https://kotlinlang.org/](https://kotlinlang.org/)

# 3. Blockchain and Cryptocurrency

Blockchain technology is not going anywhere anytime soon. We've seen the kinds of disruption that Bitcoin, Ethereum, and even Dogecoin have created. Cryptocurrency has steamrolled ahead, while traditional banking and investment institutions have fought it tooth and nail. I am not going to explain the ins and outs of how the blockchain works here, but I believe that knowing how to program apps to take advantage of this technology is an extremely valuable skill to have.

Cryptocurrency essentially removes the middleman in finance. Bitcoin and Ethereum are not controlled or owned by a centralized bank or printed from the government. Because of this, they are seen as more private and a way to future-proof against inflation and any changes to the value of the dollar. This is absolutely crucial. A bitcoin is worth the same everywhere in the world.

Why is this important for us as developers? Well recently, Tesla announced they would be accepting Bitcoin as payment and not converting back into a stable coin or into USD. This is a massive step forward for cryptos. If things keep moving this way, there will come a time when developers need to know and understand how to build apps that can integrate with the blockchain. As more people start investing in and taking an interest in cryptocurrency, the demand for being able to use it for commerce in websites and apps will only grow. 

My advice for getting started would be to learn Solidity, the programming language used for building apps to take advantage of Ethereum. You will also need a knowledge of languages like Python and JavaScript to be able to let your users interact with your applications. Below is a simple Hello, World app taken from Solidity's website.

```
pragma solidity ^0.8.0;
contract MyContract {
    function helloWorld() public pure returns (string memory) {
        return "Hello, World!";
    }
}
```

More information can be found at [https://soliditylang.org/](https://soliditylang.org/)

# 4. GraphQL

Moving away from broader language categories into more design and architecture, GraphQL aims to solve a couple of the problems of REST APIs. It was designed by Facebook to in order help them streamline getting data from their servers to their client apps.

Instead of declaring endpoints for your API, you have one GraphQL endpoint that you pass your queries and mutations to. A query is essentially a defined set of data you want back from your server. You would use queries to define the structure of the data and how many records you want back from your server. Mutations can be thought of as a traditional create, update, or delete command. You send data to the server that you are creating or updating or whatever you want to do with it.

GraphQL aims to simplify retrieval and management between clients and servers. You no longer are fetching more or fewer data than what you expected and really don’t need to create a bunch of DTOs to manage requests and responses. You just define your object types and then you can specify what fields from it you want your server to return.

Will GraphQL replace REST? Well no, I don’t think so. Each has a specific use case. Sometimes, setting up a REST API might work better for your app. Other times you might want to use GraphQL. Why I think GraphQL is worth learning because of how much more complicated our data is becoming. Complicated data models no longer need to have complicated logic to build your dataset on your backend. With GraphQL, you tell the server exactly what you want back.

You can learn more about GraphQL at [https://graphql.org/](https://graphql.org/)

# 5. Docker

Docker has been a tool that I cannot live without. Docker is a tool used to help simplify code environments. You pull down an “image” of an existing environment, say like one for Python or JavaScript, and using a file called a Dockerfile, you can copy your code into the image and run it there instead of on your machine.

There are a number of advantages to this from a developer's perspective. You, for one, can keep your development environment off your local machine. All your dependencies and code are isolated in the image. This helps prevent any headaches you might run into with running your environments locally. It also makes sharing your environment with team members easier. All you need to give them is your code and the Dockerfile and they can use the code exactly how you have it set up on your machine.

You can also set up more complicated environments using Docker Compose, where you can create environments using multiple images. You can spin up databases, message brokers, and more, all without having to download and install these pieces of software on your system. You can then reference those within your software, whether you are running that in a container or not. It greatly simplifies the process of creating and managing development environments.

This can be taken a step further with tools like Docker Swarm and Kubernetes, which make the process of setting up and configuring production environments much simpler. Being able to package and deploy software in containers like this greatly reduces the risk of taking down the whole system. Again, having all your configurations and applications isolated in this way really helps to ensure that your code will run exactly the same way no matter where it is.

Like with GraphQL, Docker and container technology helps solve complicated business infrastructure. With more and more components to applications now, and with them becoming more microservice oriented, Docker is an essential tool for developers to learn and use. The power and flexibility it gives you to control every part of your stack and deploy it with confidence are invaluable to any development workflow.

More information on Docker can be found at [https://www.docker.com/](https://www.docker.com/)

# Conclusion

The world of development is constantly changing and evolving, and we as developers have to stay on top of it. How software is written and the tooling we use to create it can change overnight sometimes. It’s important to constantly be learning and adding new skills to what you know.

These skills and technologies I have discussed are a great way to do just that. More mainstream languages are introducing functional elements into their syntax. Our home appliances and phones are not only getting smarter, but more available and more complicated. Swift and Kotlin are great languages to learn in that regard. Blockchain technology will continue to grow and become more widely adopted as the demand and awareness of cryptos continue to grow. GraphQL and Docker are tools to help with how you build your apps and fetch data for them. They solve the issues of deployments, APIs, dependencies, and so much more. With these skills, you are not only helping to write better software, but you are also helping to future-proofing yourself.

(Photo by Firos nv on Unsplash)