How to choose the right technologies for your project?
Each project is different, and the scope may require the specific use of certain languages or technologies. Sometimes, the solution sought is linked to the use of a particular technology: the decision of the tech stack is therefore immediate.
This is not, however, the case for all projects. Indeed, the range of technical options to meet the need is in most cases quite broad. In this situation, we are able to propose the use of a set of technologies on which the developers are experienced, and that meets the need.
One of Apptitude’s core values is technical rigor, which is why we are constantly listening to what’s new in the sector. We value open-source technologies, and use State-of-the-Art solutions proven in the relevant fields. Although each developer has its own area of expertise, it is important to capitalize on common knowledge and past achievements. It is therefore a constant juggling between the new (allowing us to improve) and the known (allowing us to be efficient).
Our technology stack will evolve over time, but it is also maturing. It allows us to efficiently develop new projects in accordance with the values that are important to us. Today, let’s stop for a moment to take a look at which technologies Apptitude uses most often.
For a high-level view, let’s look at the languages we use. We store the code for the vast majority of our projects in private repositories on GitHub. GitHub gives us a first glimpse of which languages we use the most:
An overview of our projects reveals that we use a wide range of technologies. As an example, here is a small listing of the tools we use on a regular basis. This list is not exhaustive and rather aims to highlight technologies that have a certain impact on the way we develop. We voluntarily exclude here a very large number of libraries with a minor impact.
We can easily separate the environment in which our code will be executed into several typical “components”. The realization of a project is not limited to a single technological choice: it is a process where we identify the different components, their interconnections, the constraints of the system and how it interacts with the outside world. Therefore, each choice is made taking into account not only the local environment in which the code will be executed, but also its relevance to the project as a whole. More than pure technique, it is here that engineering and software architecture skills are important and valued.
Frontend web development
- Frameworks: Next.js, React, Vue.js
- Tools: Webpack, Babel, ESLint, Docz, i18next, Pontoon, Mocha, Jest, Cypress
This code will be executed on mobile devices, such as smartphones and tablets. There are several types of developments for these devices: It is possible to go for a solution very close to the specific operating system, this is called “native” development. Or it is also possible to develop a more generic solution called “hybrid”, which is sometimes implemented using web technologies.
- Frameworks: Android natif, iOS natif, Xamarin, Ionic, React Native, Flutter
- Services: BitRise, MSCenter
This part of the code will run on infrastructures that we control: our servers. It is the invisible part of the iceberg of the development of a technical solution. The code here will often manage key technical challenges in the lifecycle of an application, such as database management, or user authentication.
- Langages: Node.JS, Python, PHP, Java
- Frameworks: Koa, Django, Flask, Symfony, Laravel
- Outils: MongoDB, MySQL, PostgreSQL, Pontoon
Writing, reviewing, maintaining, testing, debugging and deploying code correctly and at scale for our customers is also a technical challenge to solve. We use a number of services and tools that automate these processes as much as possible in order to relieve us of some of the burden of repetitive tasks that are often prone to human error. Unless the project requires otherwise, we always favor the use of services located in Switzerland.
- Technologies: Git, Docker, Docker Swarm
- Outils: Portainer, Redis, InfluxDB, Traefik, GlusterFS, GrayLog
- Services: Infomaniak, Exoscale, CircleCI, DockerHub, AWS, Google Cloud Platform, Rollbar, InstrumentalApp
Embedded / Connected objects
We have also worked with a wide range of connected objects; whether they are machines, sensors or home automation objects. These systems generally involve very rigid and specific development constraints. There are very few universally reusable solutions. However, the common point of all these systems is that they are typically intended to be connected to other parts of a system. We are therefore used to making these objects communicate with the less constraining parts of our applications, whether we write embedded code in Python, Java, C# or C++.
- Languages: Python, Java, C#, C++
Although each project is different, we have a few recipes and combinations of technologies that work very well together. We will disclose more details in a future article. ? But in the meantime, here are 3 examples of “technology stacks” that we propose and regularly use.
Example of a web frontend stack
For a project using React as a rendering library on the frontend side, we built a codebase using Next.js as a framework to automate resource compilation, transpilation of derived languages, static resource pooling, as well as a development server and a production server. Our other tools such as test frameworks integrate seamlessly into this toolbox as well.
Example of backend stack 1
Example of backend stack 2
Some of the projects we carry out may have similar needs. This is why we implemented this example of a technical stack on the server side, using Python and django. This framework allows us to quickly build a solid base for a project with a back office. We also have a part of code that allows us to use Vue.js with Parcel for frontend development if necessary.
The technology to be used for a project is therefore important. Each option comes with its advantages and disadvantages. An analysis of the constraints and points of complexity of a project allows us to choose the tools that will facilitate their integration. And when the project allows an important technical freedom, we are able to suggest proven technical stacks in order to efficiently build the requested functionalities.