Deploying (Small) Applications It Is Too Complicated in Many Cases
So let’s face it. A lot of code is written by people who aren’t software engineers. The companies they work in are not software first.
They are experts in a certain domain with coding skills. Maybe they are a really good coder, but most likely they try to solve a problem quickly, because they are not paid to write code and orchestrate its deployment.
They are people just like me. My background is in electrical engineering and even though my education entailed some coding classes, the were rather abysmal. However, coding is a big part of my research in electromagnetical wave propagation.
There are plenty of people like me who want to share the functionality of their code with others, but haven’t found a simple way to do so.
I find available cloud solutions are too complex to master on the side and I would have to adapt my code for it to work in the cloud anyway. The problem is, that there isn’t much understanding for this kind of work in academic and traditional engineering settings.
Some of the main selling points of the cloud are that you don’t have to manage your own infrastructure and you can scale easily if needed. However, even just getting started with simple examples is a rabbit hole.
So what I am really looking for is a simple solution to allow me to share my applications with other with as little effort as possible.
Sharing a binary
Traditionally, people would compile their code and share a binary with others. This can get really messy quickly because of the plethora of architectures and platforms. In engineering & science contexts this is especially problematic because everybody tends to work with what they know best.
Furthermore, creating binaries for script languages such as Python is possible but also not quite as straight-forward as I wished it was. This is especially true for scripts that have some more exotic dependencies.
Sharing the code
Sharing the code with other people is perfectly fine as long as everyone involved has got the skills to get it up an running. Oftentimes, this is not the case. Even if it is, it can take a considerable amount of time for more complex projects. If you just want to use the application that might not be viable in a company context.
Sharing the implementation is also not always possible. Maybe people on different teams cannot share code due to restrictions or you want to allow your customers to use your application. You likely do not want to give away your source code in such cases, especially if the code is part of your core IP.
Using your own server
You can also share your applications through your own servers. You set up the server, configure everything as needed, and run a web server that allows others to use your application.
Wait. How do others use your application? Either via a browser or via an API but your code doesn’t have a web frontend or API endpoints. Unfortunately, that means that you have to significantly extend your code to make it work with that approach.
Besides, hosting your own servers isn’t a piece of cake either and you likely need extra people to manage that.
Using the public cloud
One of the more recent approaches to this topic is the deployment of your application in the cloud. This takes away the overhead of hosting your own servers but now you have to configure your cloud providers services in order to work for you.
That’s not as easy as it sounds, because the common cloud providers offer a large variety of different services for different use cases and without a lot of time and some fitting training/certifications you are probably lost.
Furthermore, you still have to adapt your code for the cloud application model your provider and their services choose to implement. This is perfect if you work as a software engineer in a company that makes money by selling software, because that’s what those systems are made for. You have the time and the resources to actually benefit from the cloud.
However, for engineers or small software teams in companies whose main money maker isn’t software, it’s too complicated and thus takes too much time.
If you want to share the functionality of your code you have different choices but all of them come with significant drawbacks. All of them take too much time and effort to get right.
Most importantly, you don’t want to press your code into a programming model that might not even fit your use case.
The tooling for the deployment needs to be simple. One click or one command in the terminal, and your application should be up an running.