Software Development @ Engineering USA

At Engineering we like to solve problems, and we strive to provide each of our customers the solution that best fits their problem. Sometimes this means leveraging one of our partner’s state-of-the-art products and customizing it, and sometimes this means going off the beaten track and trying to invent something entirely new to perfectly match our customer’s needs.

Building a solid and maintainable product is a difficult task, however. What might seem like the fastest way to ship and finalize a product usually ends up incurring a higher overall cost due to the maintenance problems that arise after the product has already been shipped. Creating and maintaining software requires well-established quality standards and methods to deliver a superior product in a timely fashion.

Lately, Engineering has been working on developing customized software solutions, both for our customers and for our partners. This new undertaking required rethinking the way software is created and shipped at Engineering, in order to achieve higher standards of quality.

In this article, we will highlight what makes Engineering capable of delivering customized software solutions that meet industry standards and embrace the most modern technologies, as well as take you under the hood and show you the inner workings of our software development practices.

Goals

In one sentence, we can define any project as successful when it meets the customer’s or stakeholders’ expectations. In the case of a successful software development project, this can be reached when the following goals are met:

• High Quality: The delivered product reflects the customer’s needs with attention to the smallest details.
• Reliable: The software has undergone careful testing to remove the occurrence of bugs that might disrupt the usage experience.
• Fast Delivery: It is important to deliver the project on time to meet the customer’s deadline.
• Maintainable and Extendible: All software needs to be maintained. As such, it has to be designed in a way that facilitates the maintenance after delivery and enables easy modification in case the requirements change or new requirements are added.

Engineering Agile

In the last 15 years, a new philosophy called Extreme Programming (XP) has started to spread in the world of software development. XP allows small teams to tackle big projects and cut maintenance costs. A lot of methodologies for software development were born following different declinations of XP principles. As a collection of high-level concepts and principles, XP is very valuable, but it sometimes clashes with some preconceptions that linger in software development, especially when, in the case of Engineering, we have to deal with legacy solutions and enterprise technologies.

At Engineering, we leverage the core principles of agile methodologies when we have to build our software, and we design a simple workflow that is scalable, so that it can be used in a one-man project as well as in a project with ten people or more.

Our approach helps us in many ways. We start by setting a deadline for an MVP (Minimum Viable Product) that we can show to our customers as soon as possible; from there, we proceed in short iterations until all the use cases are covered. This allows us to communicate with customers easily and receive feedback as soon as possible, when changes are less expensive. Our customers are happy to be involved in the development, follow the project from the beginning, and see the actual progress of the work on a daily basis. The agile approach allows us to tackle any additional requirements or a newly discovered bug very quickly, and ship the modification after delivery without hassle.

Our approach mixes some aspects of Scrum for what regards the management of the sprints, and github-flow for what regards the management of the code base and the issue tracking.

Standardized Approach

When building software, it’s important to standardize the procedures and rules to be followed throughout the development process. At Engineering, we select our technologies and tools based on what is more productive and better meets industry standards, and we develop internal rules and assets to apply to the projects themselves. This allow us to have a more cohesive portfolio of products, easily make integrations amongst different projects, and re-use business-independent modules. When we have to start a new project, it is very easy to kick start the solution and start writing the code that actually does the job, because we can leverage a well-tested mix of technologies and workflow. Engineering uses and enforces the following to ensure that our process and product meets the highest quality standards with the lowest impact on cost:

• Automated Code Style Checking Rules
• Automated Code Static Analysis Rules
• Automated one-click deployment workflow
• Internal rules and conventions across different projects

Source Control

We believe that source control is one of the most important (and most overlooked) components for ensuring high quality standards in software development. Not using a source control method properly causes the code to get “dirty” over time, dramatically increasing technical debt that can sink a project before it even gets deployed.

At Engineering, we treat the source code as the most important design document, and we take extra care to ensure that only well-tested and high-quality code makes it into the final product. We use GitHub to host our projects and we use their issue tracking tool and pull request mechanism for communicating both internally and with our customers.

We also leverage the power of source control when we have to maintain different branches for different deployments of the same project, in which each deployment could have additional requirements or needs to target a specific customer or plant.

Code Review

Two pairs of eyes are always better than one, so we like to make reviews of the code before it is accepted in the main code base. This helps to spot bugs and code smells, or inefficiencies in the code, as a result cutting technical debts. Code review also fosters the spread of best practices amongst developers, so that anyone can recognize, address and learn from their mistakes faster, not to mention prevent those mistakes from affecting the quality of the product.

Test Driven Development (TDD)

We always test every functionality, and every time a new functionality is added, it must be accompanied by a test that covers all the use cases. We like unit tests, because they can be run without additional expenses every time the code changes to ensure that the modifications don’t break previously introduced functionalities.

Continuous Integration & Continuous Delivery

At Engineering, we like automation. Automating tasks means that you can delegate a machine to do the boring chores for you, and computers are well known to execute boring chores in a very fast, inexpensive and error-free manner. We use grunt and gulp to create our test and deployment tasks. We use the awesome AppVeyor CI to run our task automatically every time the code is modified. For example, with Continuous Delivery, we can automate all of the following tasks on the CI server and with a single command, also enforcing that the project built doesn’t depend on the environment it was built on:

• Style Analysis
• Static Code Analysis
• External dependency resolution
• .NET project compilation
• JavaScript project compilation
• Minification
• Test Running
• Assets compression
• Documentation PDF generation
• Installer compilation

This makes building a project from the source code a very inexpensive, replicable and error-free process. Every build is also strongly identified by a version number so that we always know which version is deployed.

Web-Oriented Technologies 

The development world has dramatically changed in the last 5 years: we have seen a global shift towards web-based products. Engineering embraces this trend by providing web-based solutions and choosing cutting-edge technologies to leverage this new way of building software.

The newest web-based technologies allow us to develop projects faster and without errors, and to make deployment an easy, replicable process, consequently cutting costs and yielding significantly higher quality products. We focus on specific technology stacks to create a well-tested and solid workflow:

• C# and .NET because these are the de facto standard in manufacturing and enterprise IT
• SQL Server provides the most solid solution when it comes to managing a database for the manufacturing industry
• ServiceStack is a .NET-based framework to build solid and extensible web services and REST APIs
• Typescript unites the formality and the safety of static typing with the versatility and speed of JavaScript and client side libraries
• NodeJS and grunt automate our tasks and leverage many client side development best practices
• AngularJS allows us to build very rich and interactive user interfaces with an absurdly low amount of code
• npm and nuget are our dependency management systems of choice for clients and servers respectively

The result is software that is easy to use and install, with a modern looking User Interface (UI), powerful debugging capabilities and a diagnostic, light hardware footprint, and fast.

Engineering

At Engineering, we embrace the Open Source philosophy in software development, and we try to introduce this concept into the world of manufacturing and enterprise IT.

Modern development workflow is heavily based on Open Source. This trend can also be seen in the latest Microsoft policy toward development technologies: the Redmond giant has always been renowned for its closed source policy, but in the last year it has open sourced the majority of its .NET platform. This is a clear sign that, even for enterprise projects, the time has come to leverage the enormous potential Open Source Software (OSS) can offer.

At Engineering, we rely on a lot of OSS for our core components, and we like to show our commitment by open sourcing many modules that are not our core business. You can find our Open Source projects at https://github.com/hylasoft-usa. We do this not only to help the community grow, but to help us to develop with modularity in mind, and provide highly reusable and easily manageable dependencies.

Reusability

We think it’s important to not reinvent the wheel every time a new project is started. It would be nice to start to write the core business code on day 1 of development, but of course there are many side tasks that need to be implemented first for each project, from the logging mechanism, to the integration to external systems, the authentication, the reporting framework, and utility libraries. When a project is finished, we look at what parts can be extracted and reused independently in other projects. This not only allows us to drastically cut the work and the lines of code for each project, but it also increases the quality of the product and reduces technical debts, since each module is completely independent from a single project, and it has already been unit tested and used.

What's Next?

At Engineering, we are always looking for new ways to improve our development workflow and refine our technology stack. We are living in a very exciting time for software development and we are sure that the enterprise world will be revitalized by these paradigm shifts.

Many concepts are making their way from the world of innovative tech start-ups to the industrial world: container-based development such as the type provided by Docker promises to be the de facto standard to substitute the older virtualization model, the near future promises to be a very interesting period for experimenting with wearable technologies and Augmented Reality, and the Internet of Things (IoT) is becoming more and more important in manufacturing.

At Engineering, we don’t want to miss a single opportunity to change the world of manufacturing, and as always, we are very excited to work with our customers and partners on projects to make these ideas reality.