Posted on

Are You 12-Factor Application Ready?

The 12-Factor Application principles for flexible applications.

There are a lot of frameworks in app development, but not all of them are tailored for today’s cloud environment. Many of them lack modularity and flexibility; some don’t even leverage the benefits of using cloud computing. The 12-Factor application principles are designed specifically for modern, containerized cloud environments from the beginning. Each component is tailored to the flexibility of containers and cloud deployment, all while creating a standard for every team member—and third-party developers— to follow.

At the same time, the 12-Factor app creates a more straightforward approach to developing a cloud app with microservices. It takes into account the need for a positive user experience and how virtual environments can be utilized for higher availability.

Posted on

Review Structural Changes in Java Code

Read on to learn more about code reviews and Java code structure!

Code reviews are a proven practice to help keep your code as clean as possible. Doing it means nitpicking every detail of each method and class: naming, length, responsibility, algorithm, style, and so on. You have to look at everything used to ensure that lines of code are understood not only by the machine (compiler) but also by humans. As humans, you or your fellow programmers will have to maintain the code.

What about the bigger picture? Well, there’s the architecture of the system. Perhaps, it just sits with the leads of your team, or perhaps it is properly documented, but generally, people know which applications or microservices are integrated with each other and in what direction the data flows between them. Somebody cares about this highest level of modularity.

Posted on

The Relationship Between Modularity and Polymorphism

Object-Oriented concepts and practices have a layered structure with both vertical and horizontal relationships between the layers and among items in each segment. The following chart shows this structure. The closer a layer is to the bottom of the inverted pyramid, the more important and fundamental it is.

As a reminder, the lowest layer consists of “Abstraction,” “Modularity,” “Encapsulation,” and “Hierarchy.” Those are the most fundamental tools in the Object-Oriented Paradigm; all other layers add more clarity to these principles. The second layer belongs to GRASP, an abbreviation for “General Responsibility Assignment Software Patterns.”

Posted on

Parallel Builds and Modularity for Faster Releases

Together, we can release faster.

Leading software development companies are now deploying software multiple times per day. In this sort of environment, even small periods of waiting can add up to significant disruptions. One of the bottlenecks we have heard from our customers lately is with their builds. If you are deploying your software multiple times per day, you are a building your software multiple times per day, the faster you build, the faster you can deploy your software. We recently reduced one of our clients build times by almost 70% using parallel builds and modularity, which allowed them to release their software faster.

You may also enjoy:  Patterns of Modular Architecture (RefCard)

How Do Parallel Builds Work?

Many popular tools support parallel builds including JFrog’s Conan, Maven, Gradle, and MSBuild. This allows you to utilize the full power of your hardware. Parallel builds analyses your project's dependencies and builds the modules in parallel based on the inter-module dependencies. According to Maven, your build performance can improve 20-50% by implementing parallel builds, but performance depends greatly on your software architecture (or how modular your software is). Below is an example representation of a software application’s dependencies. Each letter in the graph represents a module in the code.