No software development project will be successful without a streamlined and comprehensive environment set up from the onset. Only with the right tools at hand can developers make the most of their skills and experience. At Develtio, we know that perfectly well. That is why we’ve committed a lot of time and resources to come up with an exceptional combination of software solutions to make the devs’ job as efficient and hassle-free as possible. Read on to learn about Develtio’s unique approach to the environment setup in software development projects.
Neatly Stashed Containers
If you’re unfamiliar with the concept of containerization, here’s a quick recap: containers are software packages comprised of apps and their dependencies that can be launched and tested autonomously within the same or different Operating Systems. Containers remove the issue of dealing with hardware and software discrepancies between the machines used by the development team.
The most powerful (and popular) tool used for containerization is Docker. It’s a fantastic piece of software many companies employ as a fundamental component of environmental setups. So, it’s not surprising that at Develtio, we use it too. What’s far more interesting is how we use it and what we did to unleash the full potential of dockerization.
Run, Docker, Run!
Dockerization requires creating images, which are basically files containing the selected version of the app, its configuration, and dependencies. The Docker image is needed to run the application the way we want it. However, specific actions are often required for the app to be launched within a container, e.g., the source code needs compiling. And this is where it gets interesting.
At Develtio, we have come up with the idea of so-called runners, our custom-made solutions that can:
- launch Docker,
- compile the source code,
- execute other app-specific actions
The runner generates a friendly URL, where the containerized environment can be easily accessed by other developers or Project Managers. It makes the devs’ job much more streamlined and provides an experience that closely resembles the actual live server. It does sound impressive, doesn’t it? And, to be fair, we’ve barely scratched the surface. Our runners are packed with features and functionalities implemented to make Develtio’s development environment setup second to none in terms of efficiency and usability. Here are only a couple of examples:
In most software houses, when a developer needs a more experienced colleague to look into a problem, they usually copy & paste logs into the chat window and discuss it in a call. That works fine when the issue is minor and the answer is simple. But when hundreds of code lines are needed, going back and forth can be highly ineffective. That’s why we’ve made it possible for our developers to share access to their local coding terminals without sharing access to the whole machine. One simple command is enough to make the terminal available to anyone in the company.
Locally available SSL certificates
When a newly developed feature requires a valid SSL authentication to work – an official certificate must be obtained for a local domain. The process can be cumbersome, as producing the proof for the Certificate Authority that the local domain actually exists is much more challenging than it sounds. We’ve found a way to address this issue. Our local programming environments always come equipped with valid SSL certificates from the very beginning.
It’s worth adding that every step of the way, all our local programming environments can be exported into staging and production phases, further enhancing the development process’s effectiveness.
To Each Branch its Own… Environment
The difference between our development environments and the industry norm extends far beyond the local setup. All staging branches in our GitHub repository can have their own separate programming environment accessible under a separate URL. This allows for working with dockerized applications separately on every Git branch with its own customized environment.
Furthermore, we can create an unlimited number of testing environments within the same project. An application with new features can be pushed for testing independently from other branches and their environments. The process can be fully automated and also allows for autonomous testing of specific functionalities only.
Sharing Is Caring
Our containerized development environments are much more than simply smart setups created just to make our dev’s lives easier. These packages form a whole, comprehensive software ecosystem, making collaboration and knowledge sharing as efficient and transparent as possible. Our clients benefit from it, too – we make our GitHub repositories readily available to them, so our work can be monitored and tested in every stage. We’re proud of what we do and don’t mind sharing.
What can we do for you?
Talk to us about your project and let's start building it together!