In this guide, I’ll walk you through the skills, mindset, and steps needed to transition into a software architect role.

What Is a Software Architect?

A software architect is responsible for high-level technical decisions and the overall structure of software systems. The software architect acts as a bridge between business stakeholders, like product managers, and technical stakeholders, like software developers, QA, and DevOps.
Software architects’ role is to ensure the software product is scalable, maintainable, and aligned with user needs, while at the same time, it is delivered within the allocated time and budget.

Additionally, the software architect needs to ensure that the system can continue evolving over time without accumulating technical debt.

Why Become a Software Architect?

Besides the obvious prestige in being a key decision maker at your company, there are many other reasons software developers would want to grow their careers in software architecture:

• Broader Impact – Software Architects influence system-wide decisions, not just individual, isolated features

• Higher Salaries – On average, software architects earn 20–40% more than senior software engineers. In certain countries, it’s 100% higher.

• Career Advancement - You can continue growing as an individual contributor/software engineer without needing to transition into people management.

• Job Security - The entire company depends on the software architect’s vision, knowledge, and guidance, making them virtually irreplaceable

• Work Satisfaction - The role of a software architect is one of the most rewarding and exciting in the industry, with a broad spectrum of responsibilities

So now that we understand the role of a software architect and why it’s such a lucrative career path, let’s learn the best way to become a software architect.

Why Becoming a Software Architect is Challenging

Transition from software engineer to software architect is much more challenging than advancing from junior to mid-level or from mid-level to senior software engineer.
The reason for this challenge is that it requires:

• Implementation vs High-Level Design

  While engineers focus on building features and writing code, software architects design entire systems, balance trade-offs, and have to align with business goals, which even the most senior software engineer is largely not even aware of.

• Communication and Soft Skills

  A typical software engineer can get away with mediocre verbal and writing skills. However, a software architect needs to be very proficient at talking not only to technical stakeholders but also to non-technical stakeholders.
  Software architects also need to be able to communicate and document ideas across teams, using software architecture diagrams, database diagrams, etc.

• Technical Skills
  A typical software engineer is encouraged throughout their career to specialize in one area, such as backend, front-end, security, blockchain, or AI. They are also encouraged to specialize even further, like getting deep into one programming language or framework.

  In contrast, software architects need to have a broad (as opposed to deep) knowledge of everything.

So, essentially, what makes an excellent software engineer is actually far from what is required from a software architect.
This is why most software engineers get stuck and can’t jump over that skill gap, and become a software architect.

So, how can YOU overcome this skill gap? By proactively following the steps below:

How to Become a Software Architect: 7 Essential Steps

1. Think Big Picture Beyond Code

One of the biggest mindset shifts from software engineer to software architect is moving beyond the “feature”, or even short-term 1-3 months project level, to think in terms of entire systems as well as months and years ahead.
Instead of asking, “How do I build this?”, start asking:

• What components do you need? Should you implement it yourself or get an off-the-shelf component?

• How will different components of the system interact with each other?

• What trade-offs do I need to make between scalability, security, performance, maintainability, cost, and delivery speed?

• How will this system evolve over time?

• What stakeholders are impacted by your work besides your manager and fellow teammates?

You can practice this mind-shift even in your current role. The next time you’re assigned a feature, look at its dependencies, data flow, and long-term impact. This habit will make you a natural candidate for a role as a software architect.

2. Improve Your Communication and Documentation Skills

Great architects are not just technical experts. They’re excellent communicators.

Even if your design is great, if you can’t communicate it to other engineers or business executives, it will not be implemented.
You’ll need to explain architectural decisions to non-technical stakeholders in plain language, collaborate with developers using precise technical documentation, and create software architecture diagrams that convey complex systems and concepts.

Practical ways to improve:

• Start writing short technical documentation for your team

• Familiarize yourself with creating architecture diagrams (e.g., C4 model, UML diagrams, etc)

• Present small design proposals to colleagues to get comfortable in front of an audience

This skill is so important that it’s a core part of my Certified Professional for Software Architecture - Foundation Level (CPSA-F) training, which covers:

• Types of documentation for communicating design decisions, interfaces, and cross-cutting concerns.

• Software architecture diagrams include UML sequence diagrams, class diagrams, and component diagrams.

• Different software architecture views and levels of abstraction to document deployment topologies, static and dynamic views, etc.

• Best practices for communication and documentation of software architecture for technical and non-technical stakeholders.

• Standard industry-proven templates for documentation that you can follow.

3. Follow Professional Software Architecture Blogs

Staying updated on the latest practices, trends, and case studies shared by software architects (not YouTube or LinkedIn influencers) will keep your knowledge sharp and relevant.
Some excellent resources include:

• InfoQ Architecture & Design

• ThoughtWorks Technology Radar

• Engineering blogs by Netflix, Meta, LinkedIn, Uber, AWS, etc

Regularly reading from real and experienced software architects will help you develop your architectural thinking and vocabulary.

It may feel a bit daunting at first, but over time it will become easy and fun to follow those blogs.

More importantly, you will realize that the depth and quality of those blogs will directly impact the quality of your work and credibility, since other engineers will continue only learning and talking about new tools and technologies, which make little impact on your journey towards the role of a software architect.

4. Read Professional Software Architecture Books

Books require a big time investment. However, they allow you to go deeper into many topics that just can’t fit into a blog article or even a conference talk.
Some recommended starting points:

• Fundamentals of Software Architecture by Mark Richards & Neal Ford

• Software Architecture in Practice by Len Bass, Paul Clements & Rick Kazman

• Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems by Martin Kleppmann

While reading, focus on understanding why certain architectural decisions are made, not just how they’re implemented. These insights will help you in making trade-offs and design decisions at your work.

5. Go to Software Architecture Conferences

Conferences are a goldmine for not only learning software architecture but also networking with like-minded individuals. You’ll gain exposure to new technologies, software architecture trends, and hear stories from architects working in the field, solving real problems.

Some great conferences to consider:

• QCon Conferences Software Architecture Track - Typically taking place in San Francisco, London, Munich, and New York

• iSAQB Software Architecture Gathering - An annual event happening in November, Berlin, Germany, organized by iSAQB

• Goto Conferences - Gathers the brightest minds in the software community to help developers tackle projects today, plan for tomorrow, and create a better future.

If you can’t attend in person, look for virtual options or recorded sessions on their websites or on YouTube.

Conferences are a great resource, but just like books, they can be quite time-consuming. But if you have the time and resources to attend them, they are totally worth it.

6. Get a Software Architect Certificate

Obtaining a software architecture certification can be an effective way to close the skills gap, boost your credibility, and stand out in a competitive job market.

While certifications are not a strict requirement for most software architects’ roles, the right certification program can give you a clear framework for thinking about architectural decisions and a credential that signals your expertise to employers.

There are several well-known software architecture certification programs, each focusing on a different area:

• TOGAF

  One of the most recognized certifications in architecture, but it is primarily aimed at Enterprise Architects, dealing with organizational processes and enterprise-level strategy. It’s valuable if you want to work at the intersection of business and IT strategy, but it’s not focused on the day-to-day skills of a software architect.

• Cloud Certifications (AWS, Azure, GCP)

  These are great for solutions architects or engineers who need to specialize in a specific vendor’s ecosystem, either for regulatory reasons or because their company heavily depends on a specific cloud vendor. While those certifications cover cloud vendor-specific services in depth, they do not teach the foundational principles of software architecture.

• SEI Software Architecture Professional Certificate

  Offered by the Software Engineering Institute at Carnegie Mellon University, this certificate has strong academic credibility. However, it is highly theoretical and less focused on practical, real-world applications, which are required in the industry.

• iSAQB® CPSA-F (Certified Professional for Software Architecture – Foundation Level)

  The CPSA-F software architecture certification is designed by experienced software architects in the industry. This certification is vendor-neutral and is highly practical. It covers fundamental principles, architectural styles, quality attributes, trade-offs, and documentation techniques that apply to any company regardless of the technology stack.

7. Take a Professional Software Architecture Training

If you’re a busy professional and reading articles, books, or going to conferences isn’t possible, consider a structured and time-effective professional training like the Certified Professional for Software Architecture - Foundation Level (CPSA-F) by Top Developer Academy.
This training distils all the knowledge from the best resources on software architecture and presents it in a very easy-to-follow online video course.

Participants of this training learn to:

• Design an effective software architecture for your system

• Ensure the fulfillment of complex project requirements

• Apply industry-proven design principles, patterns, and best practices

• Evaluate and assess the quality of the software architecture

• Document and communicate design decisions, interfaces, and cross-cutting concerns

The CPSA-F training by Top Developer Academy is taught by Michael Pogrebinsky, an experienced software engineer and software architect who’s worked for some of the top tech companies like Google, Intel, Magnite, and others.
He’s also an experienced software architecture instructor with more than 200,000 learners on Udemy and is an accredited CPSA-F trainer by iSAQB.

Michael Pogrebinsky’s teaching style emphasises practical examples and real-life scenarios rather than just learning theory, with no fluff or fillers, which is perfect for highly focused micro learning.

Certified Professional for Software Architecture - Foundation Level (CPSA-F) Training

In addition to being highly effective at preparing learners for taking on the role of a software architect, this CPSA-F training is also accredited by the International Software Architecture Qualification Board, a global standard in training and certification of Software Architects.

By the end of the course, students are fully prepared to pass the CPSA-F exam and earn the iSAQB® CPSA-F certification - A valuable and tangible asset that signals potential employers or managers that you have the necessary skills to step into the role of a software architect.

More Articles

But how exactly do you pass the iSAQB CPSA-F exam, and what should you expect from the process?

In this guide, I'll walk you through each step to get CPSA-F certified, from understanding how to prepare for the CPSA-F exam, how much the exam costs, how to register for the exam, and so on.

What is the iSAQB CPSA-F Certification?

Before jumping into study materials, it’s important to know what the CPSA-F certification is all about so you can decide if it’s right for you.
The CPSA-F (Certified Professional for Software Architecture – Foundation Level) is an internationally recognized certification program that validates and certifies your understanding of fundamental software architecture.
Unlike college programs, this is a very practical certification relevant to the daily work of a software architect.

The CPSA-F certification is designed by iSAQB - The International Software Architecture Qualification Board (iSAQB), which is a non-profit organization made up of independent software architecture experts from industry and academia.
iSAQB was established in 2008 to address the lack of standardization in the training and certification of software architects.
Since its inspection, iSAQB has facilitated the training and certification of over 40,000 software engineers and software architects worldwide.

However, iSAQB does not conduct training for this certification.
Instead, it works with an independent network of accredited training providers and accredited trainers to teach software architecture and prepare software engineers for the CPSA-F exam.
iSAQB ensures that accredited trainers are qualified and that the accredited training provider adheres to strict quality standards.

Step 1: Understand CPSA-F Curriculum and Prerequisites

The Certified Professional for Software Architecture - Foundation Level (CPSA-F) certification is primarily intended for:

• Mid-to senior-level software developers (with at least 18 months of experience)

• Technical leads and software architects

• Engineering managers

The curriculum encompasses many topics that every software architect needs to know to perform their daily work.
Some of the topics include:

• The understanding of the Software Architect’s roles, responsibilities, and terminology

• Designing software systems based on complex requirements and making correct tradeoffs

• Applying Industry-proven principles, design patterns, architecture styles, and best practices

• Effectively documenting and communicating the software architecture to stakeholders

• Systematically evaluating and improving the software architecture

Step 2: Prepare for the CPSA-F Certification Exam

The CPSA-F exam is a multiple-choice, timed test that can be taken either online or in person at a testing center. Most candidates choose the flexibility of taking it from home with an online proctor.

The cost of the CPSA-F exam varies among the exam providers, but generally falls between $200 and $350 USD. Since the exam is not cheap, it’s highly recommended to prepare for it thoroughly before scheduling.

You can prepare for the CPSA-F certification through self-study by using publicly available materials, such as the official curriculum and official mock exam (questions and answers).

The CPSA-F exam is challenging, covering many architectural principles, design patterns, cross-cutting concerns, quality attributes, documentation approaches, evaluation techniques, and more.
Additionally, the exam doesn’t require any memorization. Instead, it expects the candidate to have a deep understanding of the software architecture concepts. In fact, the scoring system in the exam punishes (incorrect) guessing by deducting points.

So, without proper guidance from an accredited CPSA-F trainer, it’s easy to miss critical concepts, misunderstand the exam’s expectations, and fail the exam, even if you have years of experience.
Therefore, self-studying is not the recommended route for most candidates.
It’s also important to reinforce the learning with practical examples of real software architectures, demonstrated by an experienced software architect and software architecture trainer.

That’s why many professionals choose to enroll in an accredited training program led by a qualified, accredited CPSA-F trainer.

Step 3: Enroll in an Accredited CPSA-F Training Course

If you're serious about passing the CPSA-F exam on your first attempt and want to truly gain the practical skills of a software architect, then enrolling in an accredited CPSA-F training course is the best decision you can make.

At Top Developer Academy, you can get trained by Michael Pogrebinsky, an officially iSAQB-accredited CPSA-F trainer with decades of experience in software architecture, backend development, distributed systems, and training software engineers.

Top Developer Academy is the only accredited training provider offering a fully self-paced, on-demand CPSA-F training course, allowing you to study anytime, anywhere, without disrupting your work or project deadlines. This makes it ideal for working professionals who want flexibility without compromising on quality.

This training is designed to:

• Give you a deep understanding of all CPSA-F curriculum topics

• Provide quizzes, mock exams, and practical examples to reinforce learning

• Help you pass your iSAQB CPSA-F certification exam with ease on the first try

More importantly, by the end of the training, you will be able to

• Apply architecture principles to real-world systems and projects

• Get promoted, or hired as a technical lead or software architect

• Prepare you for a successful career with solid skills in software architecture

Step 4: Register and Take the CPSA-F Exam

Once you feel confident in your knowledge, whether from self-study or (ideally) an accredited training course, you can register for the exam through an iSAQB-accredited certification provider such as Certible, ISQI, or Bightest.

The exam typically consists of:

• Multiple-choice and multiple-answer questions

• 75 minutes to complete the exam

• Approximately 60 questions, with a passing score of 60% or higher

Step 5: Receive your CPSA-F Certification Diploma

After you pass your CPSA-F exam, you will receive the results from the exam provider, typically immediately after the exam.
Most exam providers will issue you a digital (and sometimes physical) certification diploma shortly after.
The digital certificate can be displayed on your LinkedIn profile. This way, potential employers and recruiters can search for engineers with this certificate on LinkedIn.
The CPSA-F certificate does not need to be renewed, and just like a university degree, it stays with you throughout your career.

Is the CPSA-F Certification Worth It?

Yes. The CPSA-F certification is designed to teach practical, industry-relevant software architecture skills and is increasingly recognized worldwide as a foundational credential for software architects. It demonstrates that you not only understand architectural concepts and patterns but can also apply them to real-world projects in a professional setting.

Regardless of the state of the IT job market, companies are always looking for software engineers who can step up and take ownership of system design, communication with stakeholders, and technical leadership beyond coding. The CPSA-F certification proves you’re ready for this role.

Many engineers who have completed the training report:

• Improved confidence in architectural decision-making

• Better communication with cross-functional teams

• Increased job opportunities and salary growth

• A clearer path toward senior engineering or architecture leadership roles

• Increased salaries as a result of being hired or promoted to a technical leader’s role

Freelancers and consultants also find it easier to secure clients with a world-class credential like the CPSA-F certificate.

Final Thoughts

If you're ready to level up your career and transition into a software architect role, the iSAQB CPSA-F certification is one of the most practical and valuable investments you can make.

And while self-study is an option, most professionals find that it’s much more effective to enroll in an accredited course led by an expert.

That’s why Top Developer Academy offers a comprehensive, self-paced CPSA-F training program, designed and taught by Michael Pogrebinsky, an accredited trainer who has helped thousands of engineers gain deep architecture skills and pass their exams.

Certified Professional for Software Architecture - Foundation Level (CPSA-F) Training

Transitioning from writing code to architecting systems presents one of the most significant career shifts for software engineers. While both the roles of a software engineer and a software architect require deep technical expertise, the architect's focus expands far beyond individual features. The scope of work of a software architect includes entire systems.

Software architects work with many stakeholders within and outside the company, and their work has a direct impact on the entire business's success.

In this article, I'll break down the core responsibilities of a software architect and also provide an effective pathway to becoming a software architect.

Software Architect is Not Just a Senior Engineer

A common misconception is that a software architect is simply the most experienced developer on the team. In reality, software architects serve a different purpose that goes far beyond advanced coding skills or specific domain expertise.

It’s also important to note that the software architect does not have to be a 10x developer.

It's not uncommon for a team to have a senior engineer who's a subject or domain expert, but does not do the work of a software architect. The key difference between the roles lies in scope and responsibility:

• Senior Engineers excel at implementing complex features and mentoring junior developers within their immediate domain.

• Software Architects design and oversee the high-level structure and strategy of entire projects and systems.

The Core Responsibilities of a Software Architect

1. Defining System Architecture and Technical Vision

Software architects create the blueprint for complex software systems, much like how building architects design structural plans before construction begins.

Their key activities include:

• System design: Creating components, defining interfaces/APIs, planning integrations with third-party services, etc.

• Selecting technology stack and tools: Choosing frameworks, databases, cloud services, and 3rd party tools that align with project requirements and the team’s skillset. While many software engineers gravitate towards new tools and shiny programming languages, a great architect doesn't just pick trendy technologies. They select the most appropriate tools and patterns to ensure system scalability, maintainability, robustness, and longevity.

• Applying architectural patterns: Applying and guiding teams on patterns and best practices like microservices, event-driven architecture, or domain-driven design. It’s also the role of a software architect to address security, logging, monitoring, caching, and error handling across the entire system.

2. Aligning Technical Decisions with Business Goals

One of the most important roles of a software architect is to bridge the gap between technology and business. Technical teams and business teams often use completely different language and terminology, and sometimes their objectives don’t fully align.
Ensuring that every technical decision serves the organization's strategic objectives is a challenging and crucial responsibility of a software architect. This responsibility often distinguishes architects from purely technical roles.

This involves:

• Stakeholder collaboration: Participating in meetings with product managers, business analysts, QA, DevOps and executives to understand requirements and constraints

• Requirements translation: Converting business needs into technical solutions and architectural decisions

• Future-proofing: Ensuring the software architecture can adapt to anticipated business growth and changing requirements

• Communication and analysis: Creating software architecture diagrams and documentation to help all stakeholders understand the system and do their part.

3. Mentoring and Guiding Development Teams

A software architect serves as both a technology leader and mentor, elevating the entire team's capabilities while ensuring consistent implementation of architectural decisions.

Guidance areas include:

• Architectural patterns: Teaching teams when and how to apply specific design patterns that scale across the organization

• Code quality standards: Establishing and enforcing coding standards that support the overall architecture

• Technical debt management: Balancing feature development with refactoring and system improvements

Great software architects elevate the performance of their entire team, making everyone better software engineers through knowledge sharing and mentorship.

Additionally, architects act as representatives of the development team when interacting with other stakeholders, ensuring requirements can be translated into realistic design and implementation plans with achievable timelines.

How Do You Become a Software Architect?

Making the transition from a senior developer to a software architect requires more than just years of experience. It requires a completely different skillset.

Some of the key skills a software architect requires include:

• Systems thinking: The ability to see the "big picture."

• Communication skills: Clearly articulating and documenting technical concepts to both developers and non-technical stakeholders.

• Strategic mindset: Balancing immediate engineering trade-offs against long-term goals.

One of the most effective ways to transition to the role of a software architect is by following a structured approach designed by the leading software architecture experts in the industry.
The International Software Architecture Qualification Board (iSAQB) is the leading certification body that sets the quality standards for training and certification of software architects. Attending an accredited training and earning the Certified Professional for Software Architecture (CPSA-F) certificate is the surest way to make a career leap to technical leadership and become a software architect.

Top Developer Academy offers the most popular iSAQB-accredited Certified Professional for Software Architecture - Foundation Level (CPSA-F) training. You can take this on-demand, video training at your own pace and on your schedule, from the comfort of your home.
Led by an experienced software architect and trainer, Michael Pogrebinsky, the CPSA-F training can provide the framework and confidence to step into the software architect role successfully.

Certified Professional for Software Architecture Foundation (CPSA-F)

Completing the CPSA-F Training Offers

• Hands-on Software Architecture Skills you can immediately apply to improve system design, technical decision-making, and your team's engineering practices. This is the main reason why many companies encourage and pay for their engineers to attend this training.

• An internationally recognized CPSA-F certification. This certification never expires and can validate your deep knowledge of software architecture. This credential can help you get promoted within your company as well as set you apart from other candidates in a competitive job market.

Becoming a software architect is a rewarding career choice, but it requires more than just strong coding skills. Understanding these core responsibilities and taking the right steps to acquire skills to fulfill those responsibilities helps you make a significant leap in your career.

More Articles

The "diagrams-as-code" approach transforms this process by allowing software architects to describe software architecture components and their relationships through code. Using code to describe software architecture diagrams enables tracking changes with version control and seamless integration into development workflows. Also, making and reviewing changes is very easy, so software architecture diagrams are always up-to-date and reflect the system's current state.

Top Tools for Software Architecture Diagrams with Code

There is a variety of tools available for creating software architecture diagrams with code, each offering unique features and benefits. Here are some of the most popular options that I’ve used myself as a software architect for creating software architecture diagrams. Those tools have minimal overlap, and you will likely use all 3 at one point or another as a professional software architect.

1. PlantUML

PlantUML is a versatile tool that supports the most common UML (Unified Modelling Langauge) diagrams, such as Sequence diagrams, Use case diagrams, Class diagrams, Object diagrams, Activity diagrams, Component diagrams, Deployment diagrams, State diagrams, and Timing diagrams.

In addition, it supports Non-UML diagrams to describe:

• Complex data types like JSON and YAML.

• Enterprise Architecture communication channels between stakeholders using ArchiMate diagrams

• Entity relationship diagrams are used to model data for databases, etc.

And so on.

Example 1: Creating a UML Class Diagram with PlantUML

Here is a simple example of a UML class diagram defined in PlantUML, and the visual architecture diagram is automatically created from this code.

@startuml
class Product {
  - id: int
  - name: String
  - price: double
  + getDetails(): String
}

class Customer {
  - id: int
  - name: String
  - email: String
  + addToCart(product: Product): void
}

class ShoppingCart {
  - id: int
  - items: List<Product>
  + addItem(product: Product): void
  + removeItem(product: Product): void
  + calculateTotal(): double
}

Customer "1" *-- "1" ShoppingCart : owns
ShoppingCart "1" *-- "*" Product : contains
@enduml

As you can see in the code above, all the classes are intuitively described using the class keyword. In each class, all the attributes and methods of the class are declared using a -/+ indicating their access control (private/public).
At the bottom of the code snippet, we describe the relationship between the classes or their instances. The relationships PlantUML supports are association, inheritance, implementation, dependency, aggregation, and composition.

For example:

Customer "1" *-- "1" ShoppingCart : owns

creates a composition relationship where each customer has only one shopping cart, and each shopping cart can belong to only one customer.

Example 2: Creating a UML Sequence Diagram With PlantUML

@startuml
actor Customer
participant "ShoppingCart" as Cart
participant "ProductCatalog" as Catalog
participant "PaymentGateway" as Payment

Customer -> Catalog: Search for products
Catalog --> Customer: List of products

Customer -> Cart: Add product to cart
Cart -> Catalog: Get product details
Catalog --> Cart: Product details

Customer -> Cart: Add another product
Cart -> Catalog: Get product details
Catalog --> Cart: Product details

Customer -> Cart: View cart
Cart --> Customer: Cart details

Customer -> Cart: Proceed to checkout
Cart -> Payment: Initiate payment
Payment --> Cart: Payment confirmed

Cart --> Customer: Purchase completed
@enduml

Since a sequence diagram is a behavioral diagram, we describe only the relationships between the actors/objects in the system, which can either be humans or system components like objects, applications, etc. The interactions are described using arrows “—>” from one actor to another actor, with a description of the action after the colon symbol.

Pros of PlantUML

PlantUML supports many software architecture diagraming notations, including UML — the standard modeling language for structural and behavioral diagrams in software design. It’s easy to use and has a fairly low learning curve. You can also customize the visual aspect of your diagrams using per-components styles and global themes.

Cons of PlantUML

While it's fairly easy to customize with color themes, its layout is a bit harder to control. It is also mainly a diagramming tool and not a modeling tool. In other words, if you want to describe the same system components but use multiple diagrams, any change will have to be done in each diagram separately to keep all the diagrams consistent.
Another big drawback is that it is unsuitable for creating software architecture diagrams for large-scale systems or cloud architecture diagrams.

2. Diagrams as Code (Python Library)

Diagrams or Diagrams as Code lets you create cloud system diagrams using standard Python code. It is a perfect tool to prototype new cloud-based systems or document existing software architectures in your company. It is also possible (though not supported out-of-the-box) to integrate it with “Infrastructure as a Code” tools to both control actual cloud infrastructure or reflect existing cloud infrastructure.

This software architecture diagraming tool supports many standard symbols from cloud vendors out-of-the-box, such as AWS, Azure, GCP, Alibaba Cloud, Oracle Cloud, IBM, On-Premise, etc.

It also supports many:

• Open-source and SaaS solutions like Kubernetes, Docker, Kafka, etc.

• Monitoring tools like Datadog, New Relic, PagerDuty, etc

• Databases like PostgreSQL, MySQL, MongoDB, etc.

• Frameworks like Angular, Flutter, NextJS, Spring Boot, Vue.js, etc.

• Programming languages like Java, C++, Javascript, Python, etc.

And much, much more.

Example: Software Architecture Diagram of Fictious E-Commerce System on AWS

from diagrams import Diagram, Cluster
from diagrams.aws.compute import EC2, Lambda
from diagrams.aws.database import RDS, Dynamodb
from diagrams.aws.network import ELB, Route53
from diagrams.aws.storage import S3
from diagrams.onprem.queue import Kafka
from diagrams.onprem.analytics import Spark
from diagrams.aws.integration import SNS

with Diagram("E-Commerce Scalable System", show=False):
    # Route53 and Load Balancer
    dns = Route53("DNS")
    lb = ELB("Load Balancer")

    dns >> lb

    # Application Cluster
    with Cluster("Application Layer"):
        app_servers = [EC2("App Server 1"), EC2("App Server 2"), EC2("App Server N")]
        lb >> app_servers

    # Storage and Database
    with Cluster("Storage and Databases"):
        db = RDS("Primary Database")
        db_replica = RDS("Read Replica")
        db >> db_replica
        cache = Dynamodb("Session Store")
        static_assets = S3("Static Assets")

    app_servers >> db
    app_servers >> cache
    app_servers >> static_assets

    # Purchase Processing
    with Cluster("Purchase Pipeline"):
        purchase_lambda = Lambda("Process Purchases")
        kafka_topic = Kafka("Purchase Topic")
        purchase_lambda >> kafka_topic

    app_servers >> purchase_lambda

    # Recommendations System
    with Cluster("Recommendations Service"):
        recommender = Spark()
        recommender_db = Dynamodb("Recommendations DB")
        kafka_topic >> recommender >> recommender_db

This example includes AWS services like Route 53, ELB, EC2, S3, RDS, DynamoDB, and Lambda, as well as open-source technologies like Apache Spark and Kafka. The code is also very intuitive and easy to understand since it uses Python, a very popular programming and scripting language. All you need to do is import the relevant classes from the diagrams module. The generated diagram uses an automatic layout and modern colors without any special code.

Pros of Diagram as Code with Python

This tool uses standard Python, so learning a new diagramming language is unnecessary if you already know Python. You can easily spot errors through an IDE like PyCharm or get compilation errors while running the tool. The library is also very intuitive, and the generated diagrams appear in a visually pleasing, professional, and easy-to-read format. This software architecture diagraming library can also be easily extended with custom symbols if required, even though it’s rarely necessary since all major systems are supported out of the box.

Cons of Diagram as Code with Python

Compared to PlantUML, there’s no support for UML or any other software architecture diagraming notations besides cloud infrastructure. Though it does have support for C4 Modeling, the support is very minimal. There’s also very little customization available in terms of the visual aspects of the diagram, such as styles, colors, and layout. Creating animations to visualize data flow between different components is also impossible.

Want to Become a Software Architect?

Becoming a software architect and technology leader is the ultimate goal for every software engineer. But you don’t need to wait for it to happen sometime in the far future!

In this guide, I share with you the 5 proven steps to becoming a software architect and technology leader today.

Use this free PDF guide to pave your path to success. Your biggest career breakthrough as an engineer is closer than you think.

Get Your Free E-Book Now!

3. Structurizr

Unlike PlantUML and Diagrams, which are diagramming tools, Structurizr is a modeling tool specifically designed for the C4 model for visualizing software architecture. C4, created by Simon Brown, is a standardized model to visualize software architecture using 4 views:

• Context View

• Container View

• Component View

• Code View.

Those 4 views allow us to represent the system on 4 different levels of abstraction or granularity.

Other diagramming tools are not suitable for creating software architecture diagrams for the C4 model because changes in diagrams in one view are not reflected automatically in other views where the same element/component is described.
Structurizr is the only tool that is aware of that connection between elements on different views, which keeps all the software architecture diagrams in sync with each other at all times.

Example: C4 Model of a Rideshare System

workspace {
    model {
        user = person "Rider" "A user who requests rides using the app."
        driver = person "Driver" "A driver who provides rides to riders."

        rideshareSystem = softwareSystem "Rideshare System" "Allows riders to book rides and drivers to fulfill those requests." {
            webAppFrontend = container "Web Frontend" "Allows riders to browse, book rides, and track them." "React"
            webAppService = container "Web Application Backend" "Handles webpage requests and user logins" "Java SpringBoot"
            mobileApp = container "Mobile Application" "Allows drivers to accept and manage ride requests." "Flutter"
            apiGateway = container "API" "Handles requests from the web and mobile applications." "AWS API Gateway"
            database = container "Database" "Stores user, driver, and ride information." "PostgreSQL" {
                tags "Database"
            }
            paymentService = container "Payment Service" "Processes ride payments." "Stripe"
            recommendationEngine = container "Recommendation Engine" "Suggests ride matches and optimizes routes." "Python"

            webAppFrontend -> apiGateway "Makes API calls to"
            apiGateway -> webAppService "Routes API calls to"
            mobileApp -> apiGateway "Makes API calls to"
            webAppService -> database "Reads from and writes to"
            apiGateway -> paymentService "Processes payments via"
            apiGateway -> recommendationEngine "Fetches recommendations from"
        }
        
        user -> webAppFrontend "Requests rides using"
        driver -> webAppFrontend "Receives ride requests from"
        user -> mobileApp "Requests rides using"
        driver -> mobileApp "Receives ride requests from"
    }

    views {
        systemContext rideshareSystem {
            include *
            autolayout lr
        }

        container rideshareSystem {
            include *
            autolayout lr
        }

        styles {
            element "Container" {
                background #438dd5
                color #ffffff
            }

            element "Person" {
                shape person
                background #08427b
                color #ffffff
            }

            element "Software System" {
                background #1168bd
                color #ffffff
            }
            element "Database" {
                background orange
                color black 
                shape cylinder
            }
        }
    }
}

At first glance, it may seem a bit more complex than any of the diagrammatic tools we have seen so far. However, notice that we don’t just show one diagram here. We describe a model of our entire system, with 2 views (Context View and a Container View).
Looking at the Context View, the diagram generated by Structurizr will look like this:

However, if we click on the Rideshare System (the system we are designing), we will “zoom in” to the Container View, which shows us all the containers (applications and databases) of our system.

Now, if we want to show the components of one of the containers, such as the Web Application Backend, we can take this a step further and add a Component View for this container.

To do that, we replace the component definition of the Web Application Service:

webAppService = container "Web Application Backend" "Handles webpage requests and user logins" "Java SpringBoot"

with the definition that describes its internal components and their relationships:

webAppService = container "Web Application Backend" "Handles webpage requests and user logins" "Java SpringBoot" {
    restController = component "REST Controller" "Handles HTTP requests from the frontend"
    usersService = component "Users Controller" "Handles Business Logic for Riders and Drivers"
    usersRepository = component "ORM" "Translates operations on Business Entities to Database Operations"
    
    restController -> usersService "Parses Request to passes to the service for processing"
    usersService -> usersRepository "Applies business logic and passes to the ORM for communication with the database"
}

Now that we have defined the internal structure of the Web Application, we need to add the relationship between the external API Gateway container to the REST Controller component inside the Web Application Backend and the relationship between the internal UsersRepository component of the Web Application Backend to the external Database container:

apiGateway -> restController
usersRepository -> database

Finally, inside the views block, we need to define the component view for the web application container:

component webAppService {
    include *
    include mobileApp webAppFrontend
    autolayout lr
}

And that’s it!
Now, the Web Application Container has a “zoom-in” icon which allows us to view its internal components:

If we want to zoom in and explore the internal structure of the Web Application Backend container, we can click on it and observe its Component View:

So, as we can see, using the C4 Model and the Structurizr DSL, we can create multiple diagrams for the same system, which all stay in sync if we make any changes.

Become a Software Architect: Take the Next Step in Your Career

Creating software architecture diagrams is just one part of what it takes to become a software architect. If you’re excited about designing systems, leading teams, and shaping the technical direction of projects, you’re already on the path to this rewarding career.

But how do you get there?

I’ve put together a free guide: “The 5 Proven Steps to Becoming a Software Architect and Technology Leader,” to help software engineers like you take the next step. Inside, you’ll find actionable tips on building the skills, experience, and mindset you need to transition into this high-impact role of a software architect.

Get your Free Guide to Becoming a Software Architect

Becoming a software architect and technology leader is the ultimate goal for every software engineer. But you don’t need to wait for it to happen sometime in the far future!

In this guide, I share with you the 5 proven steps to becoming a software architect and technology leader today.

Use this free PDF guide to pave your path to success. Your biggest career breakthrough as an engineer is closer than you think.

More Articles

Becoming a Solutions Architect is a rewarding career path, offering high salaries, opportunities to work on innovative projects, and exposure to cutting-edge technologies. However, success in this role requires a combination of technical expertise, strategic thinking, and the right certifications to stand out from the competition. Whether you're an aspiring Solutions Architect or a seasoned developer looking to advance, this article will guide you through the essential skills, certifications, and steps needed to excel in this exciting career.

Key Responsibilities of a Solutions Architect

To become a successful Solutions Architect, a strong foundation in technical skills is critical. These skills enable you to design effective systems, integrate complex technologies, and ensure alignment with business goals.

Solutions Architects frequently work directly with customers, handling tasks such as:

• Integrating products into customers’ ecosystems to ensure seamless functionality.

• Educating customers on best practices to maximize efficiency with the product.

• Understanding customer requirements and pain points and translating them into technical requirements for the development team.

• Collaborating with executives (e.g., CEOs, CTOs) and business teams to provide technical expertise.

• Designing custom solutions using existing technologies, products, or company expertise.

Depending on the company, Solutions Architects may also take on more hands-on responsibilities, including:

• Translating customer needs into internal technical requirements for developers.

• Creating proofs of concept and prototypes to demonstrate innovative solutions.

• Guiding implementation to ensure solutions are built as designed and meet quality standards.

• Working with DevOps, SREs, and Operations to support the successful deployment and integration of products.

• Driving technical decisions by leveraging expertise in cloud platforms, databases, and open-source technologies.

Solutions Architects operate across diverse industries, including fintech, ad-tech, ed-tech, healthcare, retail, e-commerce, and CRM systems. They frequently work with cloud infrastructure platforms like AWS, GCP, or Azure, adapting solutions to meet the specific needs of these sectors.

Solutions Architect vs. Software Architect

With so many “Architect” roles, there’s a common confusion between the role of a Solutions Architect and that of a Software Architect.
That confusion is not only among people trying to choose the right career path. It’s not uncommon for employers to mislabel a position description as “Solutions Architect” while actually listing a Software Architect's skills and vice versa.
However, it’s important to understand that while both roles focus on architecture, Solutions Architects focus on integrating multiple systems to solve business challenges, while Software Architects concentrate on designing the internal structure of individual software systems.

• Solutions Architects are often customer-facing, understanding client pain points and translating them into actionable technical solutions. They guide teams to create scalable, secure, and reliable solutions by leveraging existing technologies or designing new ones.

• Software Architects, on the other hand, focus on the internal design and technical structure of individual software systems. They are less likely to engage with customers directly and instead concentrate on creating frameworks and technical standards for development teams.

Solutions Architect vs. Enterprise Architect

Another common source of confusion is the distinction between a Solutions Architect and an Enterprise Architect, which lies in their scope and focus.

• Solutions Architects work closer to customers on specific projects, creating detailed blueprints for technical solutions that address immediate business or customer requirements. Their role is hands-on and closer to implementation, involving tools, cloud technologies, and open-source solutions.

• Enterprise Architects focus on the broad organization-wide technology landscape. They align IT strategy with business goals, ensuring that the organization’s overall architecture supports long-term objectives. They are less involved in implementation details and more focused on high-level planning.

For instance, an Enterprise Architect might define the company’s policy to move to the cloud, while a Solutions Architect designs and implements the specific cloud solution for a given project.

Key Technical Skills for Solutions Architects

So now that we understand the role and responsibilities of a Solutions Architect, let’s now understand what technical skills you need to become a Solutions Architect.
Since Solutions Architects rely on technical expertise to design complex software solutions, their most critical skills include:

• System Design: Designing scalable, secure, and efficient architectures using principles and patterns like microservices and event-driven architecture.

• Cloud Platforms: Expertise in AWS, Azure, or GCP, including core services like compute, storage, networking, and security.

• Integration: Strong skills in integrating diverse technologies using APIs, middleware, and microservices through common software architecture building blocks like CDNs, API gateway, serverless, etc.

• Automation: Familiarity with DevOps practices, CI/CD pipelines, and tools like Docker and Kubernetes

• Security: Ability to incorporate security best practices, such as encryption, identity management, and secure data flows, that conform to regulations like GDPR, CPRA, COPPA, HIPAA, etc.

These technical skills form the backbone of a Solutions Architect’s ability to create impactful, future-ready solutions tailored to business goals.

Steps to Become a Solutions Architect

Becoming a Solutions Architect can be broken into 5 steps:

• Step 1: Gain foundational experience in software engineering or IT.

  • Start by building hands-on experience as a developer, system administrator, or similar IT role to understand the basics of software and system functionality.

• Step 2: Build expertise in system design and software architecture

  • Learn the principles of scalable and secure architecture, focusing on patterns like microservices, event-driven systems, and integration strategies.

• Step 3: Develop domain-specific knowledge in areas like cloud computing or enterprise systems.

  • Familiarize yourself with industry tools and technologies, such as AWS, Azure, Kubernetes, and containerization.

• Step 4: Gain credibility to be recognized as a qualified candidate

  • Employers need clear evidence of your skills and their relevance to fulfilling the company’s needs for the Software Architect’s role.

• Step 5: Apply for Solutions Architect or related roles to gain practical experience.

  • Start with junior architect roles, consulting positions, or customer-facing technical roles to gradually take on full Solutions Architect responsibilities.

One way to accomplish the first 4 steps is to learn and acquire a relevant certification that both teaches you the necessary skills and offers an industry-recognized certification.

Best Certifications for Solutions Architects

Certifications can help Solutions Architects acquire technical skills faster while also building credibility among employers. Certifications serve as tangible proof of your skills, setting you apart in a competitive job market and opening doors to high-growth opportunities. They also help in moving between companies since professional certifications and their quality standards are recognized by all employers.

Top Cloud Certifications for Solutions Architects:

1. AWS Certified Solutions Architect – Associate/Professional - AWS has the biggest market share among all cloud vendors; this is one of the most popular certifications for cloud-focused solutions architects, opening doors to companies using AWS services.

2. Microsoft Certified: Azure Solutions Architect Expert - Perfect for architects working on Microsoft Azure and Microsoft ecosystem - Very common for governments and contracting agencies that work for the government

3. Google Professional Cloud Architect - Designed for professionals using Google Cloud Platform (GCP) and is particularly strong for companies working in Big Data, Machine Learning, and AI.

Limitations of Cloud Certifications

While cloud certifications are great for getting a foothold at companies that use cloud services, which are the majority of companies nowadays, there are trade-offs to consider:

• Vendor Specific - A cloud certification’s value is limited when applying to companies that use a different cloud provider. For example, AWS certification won't translate directly to Azure or GCP roles. Cloud certifications focus heavily on vendor-specific tools, making the knowledge less transferable across platforms.

• Expiration - Cloud certifications expire, typically within 3 years, which require you to retake the certification exam and pay the applicable fees. Renewing cloud certifications requires time and effort to prepare for exams, which can be challenging if you hold multiple certifications from various cloud providers.

An Alternative to Cloud Certification for Solutions Architects

While cloud certifications have their value, they often fall short in addressing the broader needs of a Solutions Architect. This is where a certification like the CPSA®-F by iSAQB® (International Software Architecture Qualification Board) can offer a more long-term and broader skillset for Solutions Architects.

The Certified Professional for Software Architecture – Foundation Level (CPSA-F) is a strong complement to cloud certifications, equipping Solutions Architects with vendor-neutral skills that make them adaptable across any technology stack or cloud environment.

The CPSA-F® certification program equips Solutions Architects with essential technical skills such as:

• Architectural Thinking:

  • CPSA-F teaches core software architecture principles, focusing on designing systems that balance quality attributes like scalability, performance, and maintainability. This foundational knowledge is applicable to Solutions Architects, who often design systems that integrate multiple technologies.

• Communication with Technical Teams:

  • Solutions Architects act as a bridge between business needs and technical implementation. CPSA-F certification training equips them with the technical language and frameworks to communicate effectively with software architects and developers.

• System Design Skills Beyond Cloud:

  • While cloud certifications (AWS, Azure, GCP) focus on platform-specific solutions, CPSA-F provides a vendor-neutral foundation for system design. This is particularly useful for Solutions Architects working with hybrid or on-premise systems in addition to the cloud.

• System Integration Knowledge:

  • The CPSA-F certification curriculum covers architectural strategies for integrating components and technologies, which is essential for Solutions Architects, who are responsible for ensuring seamless interoperability between systems.

As an added benefit, unlike cloud and many other IT certifications, the CPSA-F certificate never expires. This means you can focus on applying your skills rather than renewing certifications, saving time and money.

Preparing for CPSA-F Certification

To earn the prestigious and internationally recognized Certified Professional for Software Architecture - Foundation Level (CPSA-F) certificate, you need to take an exam by one of iSAQB’s accredited certification bodies. The exam itself is pretty challenging as it tests the candidate’s proficiency in a wide range of topics, critical for the role of a Software/Solutions Architect.

Therefore, the best way to prepare for the CPSA-F exam is to enroll in an accredited CPSA-F training. After completing such a training, you will have the skills to succeed in your job, as well as pass the CPSA-F certification exam.

Certified Professional for Software Architecture - Foundation Level (CPSA-F) Training

In the CPSA-F training, you will learn how to:

• Design the most suitable software architecture for your system

• Ensure the fulfillment of complex project requirements

• Apply industry-proven design principles, patterns, and best practices

• Evaluate and assess the quality of the software architecture

• Document and communicate design decisions, interfaces, cross-cutting concerns, and more

By the end of the training, you will be fully prepared to take the certification exam and earn the CPSA-F certificate.

As an accredited iSAQB training provider, Top Developer Academy offers the only on-demand, self-paced online training that fits your busy schedule. This training is led by an accredited iSAQB training provider with years of practical, real-world, and teaching experience. To read reviews and testimonials of engineers and solutions architects who already completed this training, click here.

Don’t wait to accelerate your career. Enroll today in Top Developer Academy’s CPSA-F training and gain the skills to become a world-class Solutions Architect.

More Article

In this article, we’ll explore the unique advantages of TOGAF and CPSA-F and guide you toward the one that can make the biggest impact on your future as a software engineer, developer, or IT professional.

Enterprise Architect vs Software Architect

Before diving into the TOGAF and CPSA-F certifications, it’s essential to understand the difference between the roles they support. An enterprise architect (supported by the TOGAF certification) focuses on high-level strategy, aligning IT infrastructure with broader business goals. An enterprise architect oversees an organization’s technology landscape, ensuring systems are cohesive, scalable, and supportive of long-term objectives. Enterprise architects often engage in planning, governance, and aligning technology with business strategy.

It’s important to understand that while enterprise architects focus on broad organizational goals in IT organizations, they don’t handle many of the technical, hands-on responsibilities that software architects do. Enterprise architects typically don’t work on code-level design, detailed component structures, or hands-on development. They also don’t engage in the specifics of application performance tuning, database optimization, or choosing software frameworks for individual projects.

On the other hand, a software architect (supported by the CPSA-F certificate) is much more hands-on with system design. They dive into the nitty-gritty of creating efficient, reliable software solutions while working closely with software developers. A typical software architect develops technical designs through specialized diagrams like UML, makes technology choices, and ensures code quality within the development team while being more hands-on with code. A software architect is expected to have substantial software development experience while having a wide range of other soft skills and problem-solving skills to take complex requirements towards a production-ready software solution.

How to Choose Between TOGAF and CPSA-F®

Both enterprise and software architects hold valuable roles, yet they differ significantly in their day-to-day activities.

Enterprise architects benefit from a bird’s-eye view of how IT aligns with business goals. They often work closely with senior leadership, influencing major decisions and setting strategic technology direction. Enterprise architecture can be fulfilling for those who enjoy strategic and business planning.

Software architects, however, often find satisfaction in shaping the technical foundation of products and applications. They work closely with software developers, project managers, testers, DevOps, and other stakeholders to create software that meets specific user requirements. This path can be especially rewarding if you’re passionate about solving complex technical challenges, choosing the right design patterns, frameworks, and programming languages, working closely with development teams, and being much more hands-on with code and technologies.

Essentially, if enterprise architects are the architects of a city’s layout, software architects design each individual building.

So, if you want to be more involved in the business strategy and organizational level, becoming an enterprise architect and pursuing the TOGAF certification is the right path for you.

On the other hand, if you enjoy architecting software systems, designing APIs, and working on more technical problems in your daily work, becoming a software architect and pursuing the CPSA-F® certificate by iSAQB® - the International Software Architecture Qualification Boards is the best choice for you.

Who is the CPSA-F Software Architecture Certificate for?

The Certified Professional for Software Architecture – Foundation Level (CPSA-F) by iSAQB - the International Software Architecture Qualification Board is a leading software architecture certification for anyone with at least 18 months of software development experience who wants to master software architecture and to work towards the role of a technical lead or software architect.

This includes:

• Software developers

• Software analysts

• Engineering managers

This certification is also commonly sought after by already-established:

• Software architects

• Technical leads

• Engineering managers

• Software architecture consultants

Who want to close any skill gaps and have an independent, globally recognized certificate that can show to current or future employers or clients.

The CPSA-F certification curriculum focuses on the essential principles, practices, and patterns every software architect needs, focusing on practical skills from architectural decision-making to understanding software patterns, documentation, communication, and evaluation of software architecture.

How do you Study for the CPSA-F Certificate Exam?

CPSA-F curriculum is very comprehensive and covers many complex areas. The CPSA-F exam conducted by independent certification bodies is also considered quite difficult, even for experienced software architects, so preparing for the CPSA-F certification without guided instruction can be quite challenging.

While the International Software Architecture Qualification Board (iSAQB®) sets the Certified Professional for Software Architecture certification curriculum, it doesn’t conduct trainings on its own.

Instead, iSAQB® delegates the training to independent accredited training providers and accredited trainers who demonstrate substantial industry and teaching experience in the field of software architecture. Those training providers and their trainers are held to high-quality standards to ensure the students pursuing the CPSA-F certification get proper, practical knowledge and are well prepared to pass the CPSA-F certification exam.

Learn with Top Developer Academy

As North America's first iSAQB CPSA-F® accredited training provider, Top Developer Academy offers one of the most popular and comprehensive training for the CPSA-F certification while also being the first to offer fully self-paced training tailored for busy professionals.

Top Developer Academy’s CPSA-F training not only covers the entire exam curriculum but ensures you gain practical, real-world architecture skills, with lots of examples of software architecture, and application of the principles taught in class.

Some of the topics you’ll learn include how to:

• Design the most effective software architecture for your system

• Ensure your architecture meets complex project requirements

• Apply industry-proven design principles, patterns, and best practices

• Evaluate and assess the quality of your software architecture

• Document and communicate design decisions, interfaces, cross-cutting concerns,

and more

Certified Professional for Software Architecture - Foundation Level (CPSA-F) Training

By the end of the ​training​, you will be ready to take the official CPSA-F® certification exam and apply this knowledge in your daily work.

One of the great parts about the CPSA-F® certificate is that it never expires.

If you’ve ever earned a cloud certification like AWS, GCP, or Azure, you already know that those certificates need to be renewed every few years, which costs money.

However, since the software architecture skills you learn by taking the CPSA-F training will last you for your entire career and aren’t ephemeral like cloud technologies, this certificate is yours for life.
So, with a lifetime certification, you can build a career on timeless software architecture skills rather than worrying about renewals and changing technology trends.

Join Top Developer Academy’s CPSA-F course today and take your next big step toward mastering software architecture while gaining the skills, confidence, and certification to stand out as a top software architect in your field.

More Articles

Why Software Architecture Matters

Software architecture is more than designing systems and drawing diagrams. It’s about creating scalable, maintainable, and efficient solutions that align with business goals. By mastering software architecture, you can make critical decisions about how systems should be structured, ensuring they meet current needs and allow the system to evolve easily to address future needs. As a software architecture expert, you become a strategic thinker, elevating other engineers around you and the entire organization.

Who is iSAQB?

The International Software Architecture Qualification Board (iSAQB®) is an internationally recognized non-profit organization that defines and controls the education standards for the training of software architects. Its CPSA® (Certified Professional for Software Architecture) certification programs ensure that professionals have the skills, knowledge, and best practices needed to design robust software systems.

iSAQB® relies on volunteer software architecture experts from the industry, as well as consulting, training, and academia.

iSAQB® works with accredited training providers worldwide to offer software architecture training courses that prepare software professionals for the CPSA certification exams, which are conducted by independent certification bodies.

In addition to quality control of the CPSA-F® curriculum, iSAQB® also validates the qualification of software architecture trainers through a rigorous accreditation process.

What is the Certified Professional for Software Architecture - Foundation Level (CPSA-F) Certification?

The CPSA-F® is a foundational certification program designed for software engineers, analysts, and technical professionals who want to develop their expertise in software architecture. It covers essential practical topics like:

• Applying software architecture design principles, patterns, and best practices

• Working with complex requirements in small, medium, and large organizations

• Documenting and communicating architecture decisions

• Making design decisions and trade-offs

• Analyzing and evaluating software architecture

This certification provides a well-rounded foundation in architecture, equipping current and aspiring software architects with essential skills to lead architecture-focused initiatives and design high-quality, long-lasting products.

How the CPSA-F Training Can Help You Grow

CPSA-F® training delivers hands-on, practical knowledge of software architecture principles that you can apply directly to your projects. By completing an accredited CPSA-F training, you will develop a clear understanding of essential software architecture concepts and terminology, as well as skills to tackle real problems and communicate design ideas effectively to stakeholders.

For engineers looking to advance in their careers, the CPSA-F training provides:

• The ability to design systems that are both functional and future-proof

• The skills to transition into technical leadership roles

• Opportunities to stand out in hiring processes by acquiring an internationally recognized certificate

The Value of Earning a CPSA-F Certificate

Obtaining the CPSA-F certification demonstrates to employers that you possess the knowledge and skills necessary to contribute to or lead architecture decisions. It’s a signal that you are prepared to take on more responsibilities, whether it’s becoming a software architect, a technical lead, or excelling as a senior engineer.

Additionally, unlike many other IT certifications that expire in a few years and require you to retake and pay exam fees, the CPSA-F certificate is yours for life. The reasoning is simple — Technologies may change, but fundamental software architecture stays relevant for your entire career. This makes the investment into professional software architecture training a worthwhile investment.

Join Our Accredited Online CPSA-F Training

At Top Developer Academy, we are proud to be an iSAQB-accredited training provider for the CPSA-F certification. Our self-paced online course is designed specifically for busy professionals, allowing you to master the concepts of software architecture at your own pace and on your own schedule. Whether you want to level up your career or transition into a software architect role, this training equips you with everything you need to succeed.

With flexible access to course materials, such as:

• HD video lessons covering all CPSA-F topics

• Interactive quizzes to test your knowledge

• Practical examples of real-life architectures

• An iSAQB-approved CPSA-F mock exam

• And many additional resources

you will be fully prepared to pass the CPSA-F exam and apply your new skills in the real world.

Certified Professional for Software Architecture - Foundation Level (CPSA-F) Training

If you’re ready to take the next step in your career, the CPSA-F program is an excellent way to do so. Not only will you deepen your knowledge of software architecture, but you will also position yourself for future leadership roles and stand out in today’s competitive job market.

Join our iSAQB-accredited CPSA-F software architecture certification training and take your career to the next level!

Don't miss the chance to invest in your future and gain skills that will last a lifetime.

Enroll today!

More Articles

According to a report by Statista, 54% of developers are considering microservices architecture for their system, and the global microservices architecture market is likely to hit US$ 6.84 billion by 2027.

If you are a current or aspiring software architect wondering why Microservices Architecture keeps gaining popularity, you have come to the right place.

In this article, we will cover the benefits and challenges of Microservices Architecture and why the top tech companies are rapidly adapting it.

Why We Need Microservices Architecture

Before Microservices Architecture, most systems were designed as monolithic applications, built as single units with all components, modules, and functions coupled into a single codebase. This entire codebase was also deployed as a single unit at runtime.

While this style was simple and worked very well for small development teams, developers and software architects realized the need for a more scalable architecture style that allowed them to grow their organization while maintaining high development velocity and cost efficiency.

After the failure of SOA and other architectural styles, Microservices Architecture gained immense popularity, helping many companies we now take for granted grow from small startups to global giants.

Principles and Benefits of Microservices Architecture

Unlike in a monolithic architecture, in a Microservices Architecture, the system is divided into small, loosely coupled, and independently deployed microservices.

Each microservice has a specific purpose and is developed and managed by a separate team. The different microservices communicate with each other through standard network protocols and well-defined APIs to achieve a common goal.

A few of the benefits that come with Microservices Architecture include:

• Scalability (technical and organizational)

• High Availability and Fault Tolerance

• Flexibility and agility in adopting new technologies

• High development velocity

• Cost efficiency

• And more

Microservices Architecture at Top Tech Companies

Many companies with complex, large-scale systems, like Google, Amazon, Uber, Lyft, Netflix, Airbnb, and Spotify, have adapted microservices architecture.

The actual list of companies is very long, and it’s growing every year as more companies are gradually migrating to microservices.

In many ways, those companies owe their success to Microservices Architecture because, without it, they wouldn’t be able to scale to their current size due to high operational and organizational overhead.

Challenges of Microservices Architecture

With all the great benefits of Microservices Architecture, this style also comes with many challenges.

Taking a centralized monolithic application and breaking it into a highly distributed system brings a new set of problems and potential bottlenecks.

Some of those problems include:

• Data management across different databases

• Increased network traffic between different microservices

• Management of APIs and their changes across teams

• Deployment, Monitoring, and Troubleshooting of thousands of microservices in production

• And more

Many of those challenges can be mitigated through industry-proven patterns and best practices, which are thoroughly covered in The Complete Microservices & Event-Driven Architecture course.

But it’s also important to acknowledge that not all of those challenges can be eliminated, which is why it’s important to make a careful assessment of whether your system is going to benefit from the migration to Microservices or not.

Most startup companies and companies with small development teams will likely not benefit from this migration. But in other cases, the shift to Microservices Architecture can have a huge positive impact on the business and its customers.

If you’re a Senior Engineer, a Tech Lead, or a Software Architect looking to gain full experience in Microservice Architecture, The Complete Microservices & Event-Driven Architecture course is the best online resource to gain that knowledge.

In this course, you will learn:

• To assess whether your system is going to benefit from Microservice

• An industry-proven step-by-step process to migrate a legacy monolithic application to Microservices Architecture

• Test, Deploy, and Troubleshoot Microservices in Production

You will also learn many powerful design patterns and best practices to get the most benefit from both Microservice and Event-Driven Architecture.

More Articles

If you are a software architect or a developer working on highly scalable, data-intensive applications, this article is for you.

Distributed caching is also a common topic in System Design interviews, so make sure you’re at least familiar with the following technologies.

​1. Redis

By far, the most popular and used caching technology is Redis.

Redis is open-source, which makes it an attractive solution for any budget. It is written in C/C++, which provides very high and consistent performance.

It also offers a very easy-to-use Cli, which is perfect for prototyping before writing any code.

Integrating Redis into your application couldn’t be easier since there are dozens of client libraries (official and non-official) in almost every programming language.
Redis is much more than an in-memory key/value store.
It supports many data types and structures like Strings, Lists, Sets, Hashes, Sorted sets, Streams, Geospatial indexes, Bitmaps, Bitfields, and more.

When deployed as a cluster, Redis also supports sharding and re-partitioning for maximum horizontal scalability and replication for high availability.

It is the perfect technology for use cases like:

• Real-time applications that require low latency and high-throughput

• Storing session information to reduce database queries

• Eliminating expensive computations and network calls in a Microservices Architecture.

Redis is also available as a cloud-managed solution by the top cloud vendors:

• Amazon ElastiCache for Redis

• Azure Cache for Redis

• GCP Memstore

Becoming a software architect and technology leader is the ultimate goal for every software engineer. But you don’t need to wait for it to happen sometime in the far future!

In this guide, I share with you the 5 proven steps to becoming a software architect and technology leader today.

Use this free PDF guide to pave your path to success. Your biggest career breakthrough as an engineer is closer than you think.

2. Memcached

Memcached is a free, open-source, high-performance distributed object caching system. While Memcached is generic in nature, its primary use case is to accelerate dynamic websites by caching objects in RAM.

Just like Redis, it comes with a very powerful command line Cli which makes it super easy to query and store for rapid prototyping.

However, Memcached doesn’t support any advanced data structures, and it’s primarily a key/value store for getting and putting simple data.

This limitation also makes its API very simple and easy to use, and more importantly, provides blazingly fast performance where each operation is of O(1) time complexity, typically well under 1ms.

Memcached is made up of 3 components:

• Client software that maintains the list of Memcached services.

• A client-based hashing algorithm that decides which key goes to which service

• A server, running Memcached and stores the keys and their values

Memcached is using the LRU (Least-Recently Used) cache invalidation strategy by default, where items can also expire after a set amount of time.

Just like Redis, Memcached is offered as a cloud-managed solution by the top cloud vendors:

• AWS Memcached

• GCP Memstore

• Alibaba Cloud ApsaraDB for Memcache

3. Aerospike

Aerospike is a distributed, open-source, NoSQL database written in C++, architected with 3 key objectives:

• Creating a high-performance, scalable solution that meets the requirements of today’s web-scale applications

• Providing robustness and reliability like ACID guarantees.

• Offering operational efficiency with minimal manual involvement - A key feature for DevOps, SREs, and software developers alike

Aerospike supports a variety of client libraries for many programming languages like Java, C#, C, Go, Node.js, Ruby, and Python, as well as many other community-supported clients for Rust, PHP, and others.

Aerospike also provides a RESTful API is a great feature for today’s web-based applications.

What really sets Aerospike apart is it provides automatic sharding and strong consistency while still offering low latency and high throughput.

This makes it a perfect choice for real-time analytics and caching data that requires strong consistency like distributed “counters.”

4. Hazelcast

Hazelcast is another in-memory distributed caching solution.

Just like Redis, it supports a variety of data structures like Map, Set, List, MultiMap, RingBuffer, and HyperLogLog.

Hazecast also supports many programming languages like Java, .NET, C++, Node.js, Python and Go.

However, unlike the previous options is typically used as a data grid.

That means you can use Hazelcast as a Distributed Map, where one application instance can make a complex computation, store it within Hazecast, and Hazecast will automatically replicate that data across the entire cluster.

All the data is stored in memory, which makes requests to that data super fast.

In terms of the Cap theorem, Hazelcast can be configured as an AP (Available, Partition tolerant) system as well as a CP (Consistent, Partition Tolerant) system, which makes it super robust for a variety to use cases.

The main benefit of using Hazelcast over all the previously mentioned solutions is its caching pattern is a lot simpler and cleaner.

With all the previously mentioned solutions, if you have a cache miss, it is the developer’s responsibility to implement a call to the source database to get the data and then update the cache.

Similarly, when the data in the source database is updated, it is the developer’s responsibility to write code to propagate that update to the cache.

When using Hazecast, the developer doesn’t need to worry about keeping the source database and the cache in sync. It is done automatically.

Another benefit is Hazecast offers the ability to query data in a SQL-like language, which is intuitive for applications that use a SQL database as a main storage engine.

Software Architecture & Design of Modern Large Scale Systems

So which solution should I use?

As with everything in software architecture and system design, it’s always a trade-off.

The best solution always depends on the context and requirements of your system. However, to make the right tradeoffs, you need to have solid software architecture foundations and follow a consistent step-by-step system design process. Without this process, you might make costly mistakes that require a major refactor down the line.

If you are an existing or aspiring software architect looking to solidify your software architecture skills, Top Developer Academy has you covered.

Explore the highest-rated and most comprehensive Software Architecture and System Design courses that give you the career boost you’ve been looking for.

Not ready for a course? Download the free Ebook on The 5 Proven Steps to Becoming a Software Architect and technology leader.

Becoming a software architect and technology leader is the ultimate goal for every software engineer. But you don’t need to wait for it to happen sometime in the far future!

In this guide, I share with you the 5 proven steps to becoming a software architect and technology leader today.

Use this free PDF guide to pave your path to success. Your biggest career breakthrough as an engineer is closer than you think.

More Articles

Luckily, Amazon Web Services has long evolved beyond just being an infrastructure rental company.

For many years AWS has been offering services that make architecting and deploying highly scalable systems very easy, allowing Software Architects to focus on innovative designs and building a profitable business.

So in this article, we will cover the 5 most important AWS services any software architect needs to know to build highly scalable systems on AWS.

Those 5 services are available for any company running their system on AWS.

​1. Amazon ELB - Elastic Load Balancer​

Amazon ELB is a fully managed load-balancing service.

It automatically distributes incoming traffic to multiple application instances.

This allows Software Architects and engineering teams to deploy any application as multiple identical copies running on different computers and route user requests to those computers using different load-balancing strategies.

Amazon ELB can operate in 3 modes:

• Application Load Balancer - Layer 7 HTTP load balancing

• Network Load Balancer - Layer 4 TCP/UDP load balancing

• Gateway Load Balancer - Solution for routing traffic, managing and scaling 3rd party virtual appliances.

Using ELB, we can run 1000s of application instances transparently to the users, creating the illusion that they all communicate with one massive supercomputer.

Using Amazon ELB, Software Architects or engineers on-call can also monitor their application's health and performance, as all the requests and responses.

​2. AWS Auto Scaling ​

Amazon Auto Scaling service agents run on instances of any of the following AWS services:

• EC2 instances

• DynamoDB

• Amazon Aurora replicas

Those agents monitor and automatically adjust the capability of those services depending on policies we set ahead of time.

This allows us to increase the number of instances for a service when the load on our system is high and reduce the number of instances when the load on our system is low, which in turn reduces our costs.

Some of the metrics for Auto Scaling include:

• The Average CPU utilization of a group of instances.

• The average number of bytes received by a single instance in a group

• The average number of bytes sent out from a single instance in a group

• Average Application Load Balancer requests per target application.

​3. AWS Route 53​

AWS Route53 provides cross-region DNS-based load balancing and failure.

It is a global load-balancing service that helps reach users in any part of the world with consistent performance.

AWS Route 53 supports routing requests on a variety of strategies, such as:

• Latency - Helps reduce latency between the user and our system

• Geo DNS - Helps route traffic based on geographical locations/countries

• Geo Proximity - Helps connect the users to servers that are physical closeby

• Weighted Round Robin - Distributes traffic to different regions by sending a request to another region every turn.

For the complete list of policies, see this ​link.​

Amazon Route 53 is a perfect solution for systems that offer their services to users in multiple countries/continents.

Becoming a software architect and technology leader is the ultimate goal for every software engineer. But you don’t need to wait for it to happen sometime in the far future!

In this guide, I share the 5 proven steps to becoming a Software Architect and Technology Leader today.

Use this free PDF guide to pave your path to success. Your biggest career breakthrough as an engineer is closer than you think.

​4. Amazon Lambda​

Amazon Lambda is a Serverless offering that allows us to provide a function written in the programming language of our choice, and AWS will run its code in response to predefined events.

Amazon Lambda automatically manages computer resources on our behalf, so we don't need to worry about the following:

• OS maintenance

• Capacity provisioning

• Automatic scaling

• Security patching

• Monitoring and logging

Using Amazon Lambda, we free ourselves from managing server deployments, hiring DevOps, writing and maintaining boilerplate code or scripts, etc.

This is the most cost-effective option if we have seasonal or relatively low traffic or want to avoid managing a fully-fledged service's complexities.

​5. Amazon Kinesis​

Amazon Kinesis is a fully managed message broker and streaming solution allowing real-time ingesting, buffering, and streaming data.

It supports ​2 modes​ of managing its capacity:

• Provisioned - You must specify the number of shards for the data stream. The total capacity of a data stream is the sum of the capacities of its shards.

• On-demand (My favorite) - Require no capacity planning and automatically scale to handle gigabytes of write and read throughput per minute

Amazon Kinesis includes the following services for different purposes:

• ​Kinesis Video Streams ​- Video ingestion

• ​Kinesis Data Streams​ - Data ingestion

• ​Kinesis Firehose​ - Loading data to data lakes and warehouses

• ​Kinesis Data Analytics​ - Data processing and analysis

If you are entirely new to the above-mentioned scalability concepts and Software Architecture building blocks, or you’d like to deepen your knowledge of Software Architecture, System Design, or Cloud Computing, check out our Software Architecture courses.

These self-paced online courses are perfect for busy engineers who want to grow their careers and become subject matter experts in Software Architecture. Check out the following link for the complete list of Top Developer Academy’s online courses.

Not ready for a course? Download the free Ebook on The 5 Proven Steps to Becoming a Software Architect and technology leader.

Becoming a software architect and technology leader is the ultimate goal for every software engineer. But you don’t need to wait for it to happen sometime in the far future!

In this guide, I share the 5 proven steps to becoming a Software Architect and Technology Leader today.

Use this free PDF guide to pave your path to success. Your biggest career breakthrough as an engineer is closer than you think.

More Articles

Those companies operate some of the world's most complex and successful software systems. They are constantly pushing the boundaries of fields like Distributed Systems, Cloud Computing infrastructure, and Software Architecture to improve the end user’s experience while keeping operating costs to the minimum. Those companies want to ensure that the engineers they hire can continue making solid design and architecture decisions to keep their competitive edge, which is what System Design interviews are all about.

However, most software engineers struggle with System Design Interviews, which remains a big obstacle in their career progression and the ability to land their dream job. So in the article, we will understand why System Design Interviews are so hard for even the most experienced software developers and, most importantly, what to do about it.

1. Scope

A typical task for a junior, mid-level, or even senior engineer generally has a very narrow and well-defined scope.

Examples include:

• Adding a feature that does X

• Fixing a bug to produce X result instead of Y

• Implementing a method, class, or API that produces an expected, easily testable result or outcome

However, the scope of a typical System Design interview question ranges from one of a Principle Software Engineer to a CTO/ Software Architect of a company.

And while 1-2 engineers can easily implement most tasks we generally work on, the scope of a System Design interview question requires 10-1000 engineers to implement across multiple months or even years.

So how do you handle tasks in a scope that you’ve never handled before and doesn’t even fit in your head?

The answer to this is “abstraction”.

An experienced Software Architect doesn’t deal with implementation details, methods, classes, or even modules. And it’s not because they are not technical or don’t like coding. They developed the muscle to think and reason about system design problems on a much higher level of abstraction, where code, libraries, or even programming languages are too insignificant and even distracting.

So to be successful at a System Design Interview, you need to start thinking of big problems on a much higher level of abstraction.

2. Ambiguity

In a typical daily task of a software developer, ambiguity is minimal. Sometimes we are not sure how to use a method of a library or how to implement an algorithm optimally. But we can always find the answer on StackOverflow or in the documentation of that library. And when we don’t find the answer, we can simply prototype and discover the answer ourselves.

However, when we move to a higher level of abstraction and design a large system that potentially may not have been designed by anyone before, we don’t have that luxury. No documentation comes with designing the next Uber or TikTok. And no StackOverflow thread exists for solving a system design problem that has never been solved before.

Additionally, the scope of architecting a large-scale system doesn’t allow us to mindlessly prototype and see what works best because even prototyping is a large endeavor.

To make things even more challenging, in some cases, the client or product managers initiating a system design don’t have all the answers upfront, so the Software Architect's job is to ask those questions and reduce the ambiguity.

That is why System Design Interview questions are sometimes deliberately ambiguous, to test if a candidate can handle and find their way through the unknowns. Since most software engineers are not used to this level of ambiguity, they often find themselves lost and disoriented during such interviews.

So what to do about it?

• Acknowledge the inherent ambiguity of a System Design question.

• Ask intelligent questions that reduce ambiguity to the minimum.

• Make common sense assumptions about what ambiguity is left after narrowing down the scope of the problem.

• Architect the system in a way that leaves room to back away from those assumptions with minimal changes to the Software Architecture of the system.

Following those principles will lead you to a successful outcome of a System Design Interview because, by the end of an interview, the interviewer will be confident that you will make good design choices in architecting a real-life system, despite its ambiguity.

Needless to say, you should also follow those principles when you design a real system.

3. There is No One Right Answer

As software developers, we are always looking for the right answer. That is how we were wired in school when we learned algorithms and data structures, for instance, we always look for the best and most optimal solution. When using a library in our application, there’s usually only one right method that we need to call for each task. Otherwise, the API is considered bad and confusing.

System Design is all about Trade-offs.

Trade-offs in system design can be hard because they often involve balancing multiple competing factors. For example, a system may need to be designed to be both cost-effective and performant. These two factors may conflict, as increasing performance often comes at a higher cost. Additionally, the trade-offs can be hard to evaluate, as it may be hard to predict future use cases and scalability requirements.

An inexperienced engineer may panic and think, “oh, there are two possible options; I don’t know which one is correct. I must be wrong”.

But that’s actually OK. You are not expected to develop an optimal solution at a System Design Interview!

Instead, you must demonstrate that you can identify where such trade-offs need to be made. Weigh in the pros and cons for each. And use your judgment, based on assumptions or data the interview gives you, to make that trade-off and move on.

4. Communication

Let’s face it. Software Engineering attracts a disproportionally high number of introverts. Even extroverts like myself sometimes find it liberating to spend the entire day coding. However, System Design Interviews require a high level of communication skills.

The entire interview is actually one long discussion. The ability to discuss the problem with your interviewer, gather the requirements, explain your solution, and the thought process is sometimes even more important than the solution itself.

However, if you ask too many questions, then that is a red flag that may indicate you are incompetent.

If you talk too much and don’t ask any questions. That is also a red flag because that indicates that if you were given a real project to design, you would just run and implement it without clarifying that you are doing the right thing.

So the key is to find a balance.

Make it a two-way conversation that you drive most of the time, but allow your interviewer to take the reins when necessary.

5. Lack of Experience & Software Architecture Skills

In computer science programs at most colleges and universities, there is a big focus on what many refer to as low-level design and core computer science/programming fundamentals.

• Data structures & algorithms

• Programming languages

• Object Oriented Design

• Networking and Computer Architecture

Those are all important skills, rightfully emphasized by the education system and entry-level interviews.

However, the longer you work as a software engineer, the more you’re expected to naturally become proficient in “high-level design” and Software Architecture. So when you come to a System Design Interview or even just a typical job interview for a senior-level position, you are expected to demonstrate such skills.

But the reality is most developers don’t get to design such systems in their daily jobs. And even if you’re lucky to work at a company that runs large-scale, globally distributed systems, learning how they work on your own is not easy.

So you may have a resume working on a large-scale system, but in practice, you cannot design one on your own.

If this resonates with you, you’re not alone.

Most software developers don’t get to design the next Google or Facebook at their work. And it may take years before your manager assigns you a task that scratches the surface of that kind of scope.

So what to do about it? Be proactive.

If you are determined to accelerate your career growth, you must fill in your knowledge/skillset gaps without relying on your company/manager to hand it to you. And learning how to design such systems in practice, not only for an upcoming System Design Interview but for your own professional career progression, is super important.

That is why I created the Software Architecture & Design of Large Scale Systems course.

In this self-paced and easy-to-follow online course, you will learn the fundamentals of designing and architecting large-scale systems, which are critical for any System Design Interview.

Unlike many other System Design resources, this course is not focused on teaching you buzzwords to throw at your interviewer or memorizing names of technologies that will become irrelevant in 1-2 years.

Instead, this course will teach the fundamental skills of:

• Designing a large-scale, real-life system.

• Making correct system design choices and tradeoffs, and.

• Following industry-proven best practices.

By the end of the course, you will have the skills and confidence to handle any System Design Interview question and real, practical software architecture skills you can use in your next project.

More Articles

In this article I will share with you the 5 top books for learning and improving your software architecture and software development skills.

I consider those books a must-read for any software engineer who’s serious about their career progression, especially for those who aspire to become software architects or technical leads.

It’s also never too late or too early to read them. So whether you just landed your first full-time job, or have been in the industry for many years, you are guaranteed to learn something new and valuable from those books.

Why Those Books?

The 3 criteria for choosing this list of top 5 software engineering & software architecture books are:

• The credibility and experience of the author(s)

• The impact those books have made on the community since they were published

• The practicality and relevance of its content to our job as software developers or software architects

By reading those books, you will get the biggest return on your investment and learn from some of the best thought leaders in the industry.

And if you want to support the tremendous effort these authors took to shared their knowledge with all of use, you will find links to where you can purchase their book, in each section.

So without further ado, here is the list of top books any software engineer and software architect needs to read:

1. Software Engineering at Google: Lessons Learned from Programming Over Time

Authors: Titus Winters (Senior Staff Software Engineer at Google) and Hyrum Wright (Staff Software Engineer at Google)

Description:  This book is one of for most comprehensive guides to software engineering. By drawing a distinct line between programming and software engineering, this book illustrates the challenges of managing a living and constantly evolving codebase. In addition, the others also share a lot of their experience, architecting and developing software on a Google scale.

Some of the topics covered in this book include technical topics like Code Review, Continuous Integration / Continuous Delivery, Build Systems, and Testing 

As well as Software Architecture and leadership skills such as Leading Teams at Scale, Managing Development Productivity and Effective Knowledge sharing.

2. Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems

Author: Martin Kleppmann - Senior Research Associate and Affiliated Lecturer at the University of Cambridge Department of Computer Science and Technology, co-founded Rapportive (acquired by LinkedIn in 2012) and Go Test It (acquired by Red Gate Software in 2009).

Description: In this practical and comprehensive guide, Martin Kleppmann helps software engineers and software architects navigate through a wide landscape of tools and technologies for building highly scalable data-intensive applications.

This book will help you make informed decisions and trade-offs around consistency, scalability, fault tolerance, and complexity.

Some of the topics covered in the book include Designing Reliable, Scalable, and Maintainable Applications, Data Models and Query Languages, Data Storage, Distribution, Encoding, and Processing.

3. Refactoring: Improving the Design of Existing Code

Author: Martin Fowler - Software Developer, Author and public Speaker

Description: “Any fool can write code that a computer can understand. Good programmers write code that humans can understand.” 

When we talk about “good code” we often think of efficient algorithms or optimal data structures. However, since the majority of developers’ time is spent reading code and not writing it, there’s another equally important aspect to programming, and that is code readability. 

This book focuses on this human aspect of software development and talks about the important topics of refactoring, detecting code smells, and testing.

4. Practical Cloud Security: A Guide for Secure Design and Deployment

Author: Chris Dotson - IBM Distinguished Engineer and an executive security architect for IBM Cloud

Description: Security is a top priority for any company, and cloud-based public-facing systems are particularly vulnerable. 

This book is the most comprehensive, hands-on cloud security resource for any software developer, software architect, or security professional working on AWS, Microsoft Azure, and IBM Cloud.  

Some of the topics covered by this book include Data Management and Protection, Identity Management and Protection, Network Security, Detecting and Responding to Security Incidents, and Recovering from Security Incidents.

5. Design Patterns: Elements of Reusable Object-Oriented Software

Authors: “The Gang of Four”:

• Erich Gamma - Swiss Computer Scientist and co-creator of JUnit

• Richard Helm - Former IBM Research Staff member

• Ralph Johnson - Research Associate Professor in the Department of Computer Science at the University of Illinois at Urbana-Champaign

• John Vlissides - Former researcher at IBM's T.J. Watson Research Center

Description: If you develop and architect software in an Objected Oriented Programming language, such as Java, C#, C++, or Python, this book is an absolute must-read. 

It contains a catalog of 23 simple and succinct solutions to commonly occurring design problems that any software developer or software architect needs to know.  

The patterns are split into 3 categories: 

• Creational Patterns

• Structural Patterns

• Behavioral Patterns

Each pattern describes the unique circumstances where the pattern is applicable as well as the consequences and trade-offs of using the pattern within a larger design.

Since the publication of this book, these design patterns became the #1 skill expected from any experienced software engineer and architect, and very often come up in job interviews.

Want to Learn More?

If you are a highly motivated software engineer and want to learn more advanced topics like:

• Software Architecture

• High Performance

• Multithreading and Concurrency

• Distributed Systems

• Cloud Computing

• And More

Make sure to check out these top-rated and best-selling hands-on online courses, designed specifically for busy professionals who want to take their careers to the next level.

No time is wasted. All the topics are hand-crafted to bring you the most value.

No fillers., no lengthy introductions, and no-holding back!

More Articles

In this article, we will look at concurrency using multithreaded programming in two of the most popular languages, Python and Java. By comparing the APIs and capabilities available with each language, and looking at code examples, you will be able to make the best choice based on your end-goal and performance requirements.

Introduction to Concurrency and Multithreading

Concurrency allows different parts of your application to be executed independently at the same time. This is typically implemented using multithreading, which uses the multi-tasking functionality of the operating system to execute multiple tasks, either on the same CPU core or on separate cores. Each unit of execution is known as a thread (or a Thread of Execution). 

It’s important to note, that when we say multitasking, what we mean is that each task is making progress towards its completion. However, there’s no guarantee that at any moment, both of those tasks are being worked on at the same time.

In the diagram shown above, the program’s main thread starts two child threads, which take varying amounts of time to complete. In addition, the program continues being executed in the main thread. But after some time, the program waits for the threads to “join”, meaning that execution of the main thread is halted until the child threads complete execution. 

Multithreading in Python

Multithreaded programs in Python are typically implemented using the built-in threading module. This module provides an easy-to-use API for creating and managing threads. 

For example, here is a Python script implementing a simple multithreaded program, as shown the in the introduction diagram:

Example Multithreading with Python:

import threading
import time

def delayed_print(delay):
    time.sleep(delay)
    print(f"Hello after {delay} seconds!")

thread_one = threading.Thread(target=delayed_print, args=(5,))
thread_two = threading.Thread(target=delayed_print, args=(3,))

thread_one.start()
thread_two.start()

thread_one.join()
thread_two.join()

Output

Hello after 3 seconds!
Hello after 5 seconds!

This program demonstrates how multiple threads are executed simultaneously because even though thread_one (the 3-second delay) is started after thread_two (the 5-second delay), thread_one finishes first.

Python’s Multithreading Limitation - Global Interpreter Lock

For high-performance workloads, the program should process as much data as possible. Unfortunately, in CPython, the standard interpreter of the Python language, a mechanism known as the Global Interpreter Lock (GIL) obstructs Python code from running in multiple threads at the same time.

In other words, even if our computer has 64 CPU cores which allow multiple tasks to be run in parallel, at the same time, a Multithreaded application written in Python, will NOT be able to take any advantage of them and will run as fast (or slow) as if it ran on a single-core computer.

There is still a benefit for using multithreading with Python, but it is limited for workloads that involve simple multitasking, such as waiting for external resources (like network requests) or sleeping.

Multiprocessing in Python for High Performance

For Python programs where high throughput using true parallelism is desired, the best option may be another built-in module, called multiprocessing. This module allows you to spawn additional instances of the entire Python interpreter as separate processes, to sidestep the limitations imposed by the GIL. 

For example:

import multiprocessing
import time

def delayed_print(delay):
    cpu_intensive_work()
    print(f"Hello after {delay} seconds!")

if __name__ == '__main__':
    process_one = multiprocessing.Process(target=delayed_print, args=(5,))
    process_two = multiprocessing.Process(target=delayed_print, args=(3,))

    process_one.start()
    process_two.start()

    process_one.join()
    process_two.join()

In the above example, the work done in the cpu_intensive_work() method within process_one will have a high chance to run in parallel to the work performed by process_two.

Unfortunately, while this solution allows for higher performance through true parallelism, it imposes a critical limitation of its own. Sharing data among separate processes is extremely limited. For example, if you try to access a shared object from different processes, an error such as this may happen:

Sharing an Object Among Multiple Processes in Python - Error

# This does not work!

import multiprocessing
import time

shared_list = []

def access_list():
    print(shared_list[0]) # Print first element in list

if __name__ == '__main__':
    shared_list.append("abc") # Append "abc" to the list

    process = multiprocessing.Process(target=access_list)
    process.start()
    process.join()

Output

Output:
Traceback (most recent call last):
  File "...", line 315, in _bootstrap
     self.run()
  File "...", line 108, in run
     self._target(*self._args, **self._kwargs)
  File "...", line 7, in access_list
     print(shared_list[0]) # Print first element in list
IndexError: list index out of range

While the multiprocessing module includes a few mechanisms for sharing data between processes, as shown it is nonetheless limiting and introduces unnecessary overhead. Additionally, multiprocessing on its own has an inherent overhead in execution time and memory usage. 

Multithreading and High-Performance with Java

Similar to Python, the Java programming language includes an easy-to-use multithreading API. 

Unlike Python, though, the JVM is not limited by the Global Interpreter Lock (GIL). All mainstream implementations of the Java Virtual Machine, and Oracle’s Hotspot in particular support full parallel execution of multiple threads out-of-the-box, using a simple and easy-to-use API. 

If you want to get started with Java Multithreading and learn how to achieve the highest performance your computer can offer, then follow this link and check out the Java Multithreading, Concurrency & Performance Optimization.

In this course, you will learn how to write real-world, production-grade multithreaded Java applications, algorithms, and libraries. 

Throughout the course, you will follow industry best practices and patterns for high-performance programming in Java, and avoid all the common pitfalls and challenges which come with concurrent programming. 

More Articles

Finally, we will write some Java code to see how a PriorityBlockingQueue is used in a practical real-life example.

What is PriorityQueue

To illustrate the advantages we get from PriorityBlockingQueue, let’s compare it to the traditional PriorityQueue first.

A PriorityQueue in Java is a special type of queue which is used when the elements are required to be processed based on their priority. It is used when we don’t want our queue to follow the traditional F.I.F.O (first-in-first-out) ordering but instead gives preference to the higher priority elements. The PriorityQueue is based on the Binary Heap data structure. We will see the properties of Binary Heap later in this article.

PriorityQueue Use-Cases

A real-life example of a PriorityQueue is the hospital queue where all the patients are treated/admitted based on the criticality of the condition, patients with emergencies would be given priority over patients who came for regular health check-ups. 

Another notable example is the Operating System’s CPU scheduling which uses the PriorityQueue internally and assigns CPU-Cycles based on the priority of the threads.

PriorityQueue Ordering and Implementation

The elements of the PriorityQueue are ordered as per the natural ordering. In case a custom order is required then we can pass a Comparator at construction time.

The head of the PriorityQueue will always have the smallest element based on natural ordering or comparator, the rear of the PriorityQueue will have the greatest element based on natural ordering or comparator. 

PriorityQueue<Integer> pQueue = new PriorityQueue<Integer>();

However, we can reverse this ordering using the Collection.reverseOrder() method.

PriorityQueue<Integer> pQueue = new PriorityQueue<Integer>(Collections.reverseOrder());

As mentioned earlier, the underlining data structure that implements the PriorityQueue is a binary heap.

Binary Heap

A binary heap is a complete binary tree that satisfies the heap ordering property.

There are two types of heaps:

1. Min-Heap: Each node of the binary tree is greater or equal to its parent and the lowest element would be at the root. When we simply say heap, we refer to the Min-Heap.

2. Max-Heap: Each node of the binary tree is less or equal to its parent and the highest element would be at the root.

Concurrency and Thread Safety Issues

When we have multiple producer threads, concurrently adding items to the PriorityQueue and/or multiple consumer threads concurrently consuming items from the PriorityQueue we can have race conditions that will leave the underlining heap data structure corrupt. Because of this issue, PriorityQueue cannot support multiple producers or consumers.

If you’re not yet familiar with Java Multithreading, its performance benefits, and challenges associated with parle programming, make sure to check out the Java Concurrency, Multithreading & Performance Optimization course.

Memory Issues with a PriorityQueue

The PriorityQueue is a dynamic data structure that has no limitation on the number of elements it can accept from producers. If the number of elements exceeds the memory allocated for the JVM process, our application will crash due to an OutOfMemoryError exception.

Introducing PriorityBlockingQueue

1. PriorityBlockingQueue - Concurrency

Unlike the PriorityQueue, the PriorityBlockingQueue is thread-safe.

All of the PriorityBlockingQueue’s operations are guaranteed to be side-effect-free when it comes to race conditions or other concurrency issues. This makes the PriorityBlockingQueue the perfect data structure for production, Multithreaded Java application.

2. PriorityBlockingQueue - Unbound Capacity and Blocking

The PriorityBlockingQueue class is an implementation of the BlockingQueue interface in Java. 

In a typical producer-consumer problem in a multithreaded environment, the PriorityBlockingQueue will block the producer from adding more elements to it if the queue is full. However, since the PriorityBlockingQueue is an unbound queue, meaning that it does not have a maximum capacity, the producers will never be blocked from adding more elements to the queue. 

On the other hand, when the PriorityBlockingQueue becomes empty, consumer threads will be blocked until additional items are added to the queue.

3. PriorityBlockingQueue - Memory Efficiency and Performance

The PriorityBlockingQueue is backed by an array-based binary tree heap - which is extremely memory efficient. This provides our application with high performance and reduces the memory overhead associated with reference-based data structures.

However despite its array-based implementation, as we mentioned earlier, the PriorityBlockingQueue is an unbounded collection and it will grow dynamically as the elements get added to it.

The default initial capacity for PriorityBlockingQueue is 11, but it can easily be changed by using the appropriate constructor.

4. PriorityBlockingQueue - Ordering Of Elements

By default, the PriorityBlockingQueue is following the standard min-heap properties which mean the head of the PriorityBlockingQueue will have the smallest element based on natural ordering.

Objects in the PriorityBlockingQueue must be comparable for natural ordering, or the ClassCastException will be thrown.

For additional flexibility when it comes to the ordering of elements, a Comparator can be used. 

PriorityBlockingQueue in Action

Now that we got familiar with the PriorityBlockingQueue structure and all the advantages it provides to us, let’s see this data structure in action in a practical example. 

In this example, we’ll have a multithreaded application where a fast producer adds items to the PriorityBlockingQueue from one thread, and a slower consumer takes items from the PriorityBlockingQueue on a different thread.

This will demonstrate the ability:

• To modify and access the PriorityBlockingQueue from multiple threads safely

• For the PriorityBlockingQueue to grow dynamically as more elements are added to it

• Order the elements based on their custom priority

• When the PriorityBlockingQueue becomes empty, the consumer thread will block indefinitely until additional elements are added to the PriorityBlockingQueue

We will start with creating an Employee class:

public class Employee implements Comparable<Employee> {
    private int employeeId;
    private int age; // Older Employees Will Have a Higher Priority.

    public Employee(int employeeId, int age) {
        this.employeeId = employeeId;
        this.age = age;
    }

    @Override
    public int compareTo(Employee o) {
        if (this.age > o.age) {
            return 1;
        } else if (this.age < o.age) {
            return -1;
        }
        return 0;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "employeeId=" + employeeId +
                ", age=" + age +
                '}';
    }
}

Notice that we will use the age of the employee as the priority inside the PriorityBlockingQueue.

And since we want to provide higher priority for older employees will need to create a max-heap.

So in the following piece of code, we’re going to create a PriorityBlockingQueue with an initial capacity of 5 elements, and use a custom Comparator to order the elements in a reverse order which will create a max-heap.

Additionally, we’re creating a producer thread that adds elements to the PriorityBlockingQueue, and a consumer thread that consumes elements from the PriorityBlockingQueue based on their priority, concurrently to the producer thread.

import java.util.Collections;
import java.util.concurrent.PriorityBlockingQueue;

public class PriorityBlockingQueueExample {
    public static void main(String[] args) {
        PriorityBlockingQueue<Employee> priorityBlockingQueue = new PriorityBlockingQueue<>(5, Collections.reverseOrder());

        ConcurrentProducer producer = new ConcurrentProducer(priorityBlockingQueue);
        producer.start();

        ConcurrentConsumer consumer = new ConcurrentConsumer(priorityBlockingQueue);
        consumer.start();
    }
}

Finally here is the code for the producer thread, that adds employees to the PriorityBlockingQueue with random ids and ages.

import java.util.Random;
import java.util.UUID;
import java.util.concurrent.PriorityBlockingQueue;

public class ConcurrentProducer extends Thread {

    protected PriorityBlockingQueue<Employee> priorityBlockingQueue;
    Random random = new Random();
    public ConcurrentProducer(PriorityBlockingQueue<Employee> queue) {
        this.priorityBlockingQueue = queue;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++)  {
            try {
                int randomId = random.nextInt(10000)+1;
                int randomAge = random.nextInt(60) + 25;
                Employee employee = new Employee(randomId, randomAge);
                System.out.println("Producer adding employee: " + employee);
                priorityBlockingQueue.put(employee);
                Thread.sleep(1000);
            } catch (Exception e){ //(InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

And this is the code for the consumer thread that removes elements from the PriorityBlockingQueue based on the employee’s age as the priority.

import java.util.concurrent.PriorityBlockingQueue;

public class ConcurrentConsumer extends Thread {

    protected PriorityBlockingQueue<Employee> priorityBlockingQueue;

    public ConcurrentConsumer(PriorityBlockingQueue<Employee> queue) {
        this.priorityBlockingQueue = queue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Employee employee = priorityBlockingQueue.take();
                System.out.println("Consumer taking the element as per priority: " + employee);
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Output

Producer adding employee: Employee{employeeId=8078, age=71}
Consumer taking the element as per priority: Employee{employeeId=8078, age=71}
Producer adding employee: Employee{employeeId=8506, age=66}
Producer adding employee: Employee{employeeId=32, age=34}
Producer adding employee: Employee{employeeId=6121, age=71}
Producer adding employee: Employee{employeeId=3063, age=59}
Consumer taking the element as per priority: Employee{employeeId=6121, age=71}
Producer adding employee: Employee{employeeId=7950, age=60}
Producer adding employee: Employee{employeeId=3518, age=51}
Producer adding employee: Employee{employeeId=422, age=80}
Producer adding employee: Employee{employeeId=3820, age=51}
Producer adding employee: Employee{employeeId=5601, age=78}
Consumer taking the element as per priority: Employee{employeeId=422, age=80}
Consumer taking the element as per priority: Employee{employeeId=5601, age=78}
Consumer taking the element as per priority: Employee{employeeId=8506, age=66}
Consumer taking the element as per priority: Employee{employeeId=7950, age=60}
Consumer taking the element as per priority: Employee{employeeId=3063, age=59}
Consumer taking the element as per priority: Employee{employeeId=3518, age=51}
Consumer taking the element as per priority: Employee{employeeId=3820, age=51}
Consumer taking the element as per priority: Employee{employeeId=32, age=34}

Notice that at any given moment the consumer prefers the employee with the highest age and gets to the employees with the lower ages towards the end of the program.

Also notice that while both the producer and the consumer are adding and removing items to the same data structure concurrently there are no multithreading race conditions or any other concurrency issues.

If you want to become and expert in Multithreading and learn how to build high-performance Multithreaded applications as well as implement similar data structures for your own needs, join the best-selling course on Java Multithreading, Concurrency & Performance Optimization. In this course you will learn all the basics of Multithreading in Java, and how to utilize multiple threads to build highly responsive and blazingly fast algorithms and programs.

More Articles

The Java programming language represents this data structure with the Queue interface. Java Development Kit contains many implementations for this data structure that present different performance properties and safety guarantees. In this article we’re going to explore one particular Queue implementation, the ArrayBlockingQueue, which provides superior properties and guarantees for high performance, multithreaded, Java production applications.

Before we talk about Java Multithreading and the specific ArrayBlockingQueue implementation, let’s define a few terms that are commonly used to describe operations and actors in the context of a Queue.

Queue Terminology

When it comes to operations we can perform on the data structure, the two most important ones are:

1. Enqueue - add an element to the end of the queue. In the Java Queue interface this operation is represented by the add(), and offer() methods.

2. Dequeue - remove an element from the front of the queue. In the Java Queue interface, this operation is represented by the remove(), and poll() methods.

In the context of multithreaded Java applications there are 2 types of actors performing operations on a queue:

1. Producer - The thread that adds elements to the queue by calling the enqueue operation.

2. Consumer - The thread that removes elements from the queue by calling the dequeue operation.

Depending on the use case there may be multiple producer threads and or multiple consumer threads.

Queue in a Multithreaded Java Application

In a Java multithreaded production application environment, two concerns need to be taken into account when choosing a concrete implementation for the queue data structure.

1. Thread Safety

When working with a data structure that isn’t inherently thread-safe, many undesired side effects may happen when the data structure is accessed and modified by multiple threads. A few of those side effects include race conditions, data races and others. By trying to solve these Java Multithreading problems, developers who aren’t proficient in Java Multithreading and Concurrency may cause even more problems in a form of deadlocks or performance bottlenecks due to inefficient and excessive locking.

If you want to learn how to efficiently solve such challenges while providing your Java application with high performance make sure to check out Java Multithreading, Concurrency, and Performance Optimization online course.

  2. Bounded Size

When the number of elements in our queue grows uncontrollably to the point that we exceed the JVM’s heap size, our application may crash due to an OutOfMemoryError exception, which is generally unrecoverable. To prevent this from happening we need to set an upper bound for the number of elements we can store in our queue at any given moment. Additionally, we need to prevent any thread that attempts to add more elements to the queue from succeeding, which can be achieved by blocking that thread.

ArrayBlockingQueue

One implementation of the queue data structure that solves both of those concerns out-of-the-box is ArrayBlockingQueue, which is part of the java.util.concurrent package. The ArrayBlockingQueue uses a bounded cyclic buffer backed by a fixed-size array to store its elements.

ArrayBlockingQueue - Thread Safety

To prevent any concurrency issues and side effects due to multithreading, all of the ArrayBlockingQueue methods are protecting its operations with a thread lock.

Here are a few examples:

public boolean offer(E e) {
   Objects.requireNonNull(e);

   final ReentrantLock lock = this.lock;
   lock.lock(); // Start protected block

   try {
       if (count == items.length)
           return false;
       else {
           enqueue(e);
           return true;
       }
   } finally {
       lock.unlock(); // End protected block
   }
}

public E poll() {
   final ReentrantLock lock = this.lock;

   lock.lock(); // Start protected block

   try {
       return (count == 0) ? null : dequeue();
   } finally {
       lock.unlock(); // End protected block
   }
}

As we can see in the above two examples each operation starts with locking a reentrant lock, and each operation finishes with unlocking that lock.

ArrayBlockingQueue - Bounded Size

ArrayBlockingQueue is backed by an array, which is the perfect data structure for limiting the number of elements that can be stored inside the queue.

Additionally, to provide a clear contract for the ArrayBlockingQueue users which explicitly blocks a producer thread when the queue is already full, the ArrayBlockingQueue class implements the BlockingQueue interface instead of the Queue interface directly.

The BlockingQueue interface extends the Queue interface which means BlockingQueue contains all of Queue methods declarations but additionally it contains 2 more methods:

1. put(element) - Inserts an element into this queue, blocks the thread if the queue is already full.

2. take() - Retrieves and removes the head of this queue, blocks the thread if the queue is empty.

Let’s examine the implementations of the following methods:

public void put(E e) throws InterruptedException {
   Objects.requireNonNull(e);
   final ReentrantLock lock = this.lock;
   lock.lockInterruptibly();
   try {
       while (count == items.length)
           notFull.await(); // Block the thread until the queue has space for additional elements
       enqueue(e);
   } finally {
       lock.unlock();
   }
}

We can see that if the queue is already full the thread calling the put() method goes into a blocking state. By using the notFull condition variable’s await() method, the calling thread will remain dormant until it is explicitly woken up after the consumer thread removes an item from the queue.

Similarly, if we look at the take() method:

public E take() throws InterruptedException {
   final ReentrantLock lock = this.lock;
   lock.lockInterruptibly();
   try {
       while (count == 0)
           notEmpty.await(); // Block the current thread until there are elements in the queue
       return dequeue();
   } finally {
       lock.unlock();
   }
}

We can see if the count of elements in the queue is zero then the calling thread will be blocked through the notEmpty condition variable’s await(); method. And the calling thread will remain inactive until the producer thread adds an item to the queue which the consumer can consume.

If you want to gain deep knowledge of Java Multithreading and learn how to incorporate all the above-mentioned techniques into your own Java application, check out the Java Multithreading, Concurrency & Performance Optimization course.

In this top-rated, online course you will master Java Concurrency from the very beginning to expert level. This course is perfect for busy software engineers who want to up-level their skills and gain practical knowledge that they can apply to their projects right away.

More Articles

But what made JUnit so easy to use and hence so popular among developers? And is there any common feature between all Java frameworks that became de facto standards in their space, like Spring for dependency injection, Hibernate for ORM, and others?

In this article, we are going to explore the 2 features formula that makes any Java library a hit among Java developers.

Java Annotations

The first feature that makes a library or framework easy to use, manage and configure is Annotations. 

In addition to all the typical programming language constructs that express the program’s flow (like variable declarations, conditions, loops, expressions, etc), and the organizational building blocks that force our programs to be structured in an Object-Oriented style (like classes, interfaces, etc), Java also allows “marking” many such constructs with Annotations. 

Examples:

@Bean

@Scheduled(5)

@Test(timeout = 500)

These odd, behavior-less markings are one of the most powerful features in Java and don’t exist in many other languages. 

Since they don’t have any behavior by default, what gives them the behavior and enriches our codebase is the logic that looks for those Annotations and makes decisions based on:

• The presence or absence of an Annotation

• The Annotation type

• Values assigned inside the Annotation parentheses

For example, JUnit looks for methods annotated with @Test and if it encounters a method annotated with

@Test(timeout = 500)

JUnit knows that a test that runs longer than 500ms is considered a failure, all based on the value of 500 assigned to timeout attribute of the @Test annotation.

To discover Annotations throughout the codebase and assign behavior to the annotated constructs (such as methods, classes and fields) we need the second feature in our success formula: Java Reflection. 

Java Reflection

As we just mentioned, Annotations on their own don’t have any behavior or functionality. The mechanism that brings Annotations to life at Runtime is called Java Reflection.

Reflection API which is our way to use that feature using Java code, allows a program to inspect a class at runtime, and among others allows our a library like JUnit to look for and discover Annotations that are specifically marked for discovery at Runtime. Once an Annotation is discovered, certain behavior can be performed, which we can express in simple Java code.

For example, we provide JUnit with the following code that expresses a test suite:

   public class TestOnlineStore {

        @BeforeClass
        public static void initFakeDatabase() {
            ....
        }

        @Before
        public void prepareTest() {
            ....
        }

        @Test
        public void testTransaction() {
            ...
        }

        @Test
        public void testRefund() {
            ...
        }
    }

When we run JUnit, it will inspect the TestOnlineStore class and look for the @BeforeClass annotation to find which method JUnit should run as a one-time preparation for the test suite. Once the annotation is discovered, the initFakeDataBase() method will be executed. Notice that the name of the method is not significant and JUnit will run a method with any name as long as it is annotated with @BeforeClass and has the appropriate signature. The method execution is also done using Reflection. Similarly, JUnit will proceed to find all the methods annotated with the @Before annotation and dynamically call them before every test. And finally, JUnit will find all the methods annotated with @Test annotation, and call those methods using Reflection as well. 

The Formula

To summarize, Annotations allow us to declaratively assign roles to arbitrary code, and Java Reflection assigns that behavior to each Annotation. When we run JUnit, the library uses those two features together to find, execute and analyze our tests and provide us the result.

Using Annotations and Java Reflection we can create a framework that empowers developers without forcing them to write any complicated code, removing unnecessary barriers and boilerplate. All developers need to do is express their logic and intent through simple and non-obtrusive Annotations in the right places, and that’s it, the library Reflection based code, will do the rest.

Benefits of Mastering Java Reflection

If you want to be a true Senior Software Developer, Java Reflection is the most important topic you need to master. A true Senior Java Developer doesn’t just use off-the-shelf libraries but understands how they work to make the best use of them.

More importantly, a Senior Java Developer can write Java code which can be reused by many other engineers in their team or organization, and Java Reflection is the most important tool that allows creating generic algorithms and libraries.

If you want to step up your game and learn how to build your own Reflection based algorithms and libraries, the Advanced Java Topics: Java Reflection - Master Class is the best online resource to master those skills.

In this course, you will learn all the essential Reflection APIs through real-life examples. More importantly, you will learn Reflection best practices and rules of thumb on how to use Reflection safely and correctly to get the most benefit and performance for your application.

Follow this link and join thousands of Java Developers to Java Reflection mastery.

More Articles

For many years Java had a bad reputation for being slow. C, C++, and other languages that statically compile directly to machine code were the standard for writing applications that required low latency, stable execution with minimal jitter, and high performance as a whole. 

As far as performance is concerned, Java originally came with a disadvantage since it is a managed and interpreted language. The result of the static compilation of a Java program is a byte code that is interpreted and executed instruction by instruction by the Java Virtual Machine.

Since the memory of a Java application is managed by the JVM as well, there’s a level of overhead in the form of Garbage Collection that the JVM performs to clean up the unused objects. The JVM heap memory layout is also less efficient for objects, and arrays when compared to languages like C and C++.

However, throughout the years, there have been many advancements made in the JVM itself, that more than compensate for all those inefficiencies. And in recent years we see more and more companies use Java to develop low latency, high-performance applications for high-speed trading, scientific simulations, real-time bidding, mobile games, and more.

So in this article, I’m going to share with you 3 tips that you can apply to your Java application today to significantly improve its performance. 

1. Reduce Garbage Collection

One of the main benefits of a managed language like Java is developers don’t need to worry about freeing and managing memory. The JVM maintains internal data structures that keep track of all allocated objects. Once certain (configurable) thresholds are met, the JVM performs a multi-step garbage collection. How GC works is outside the scope of this article, but the important fact is GC time and overhead is far from negligible. Except for Azule Zing JVM, all JVM GC algorithms have a Stop-The-World (STW) phase which freezes your entire application. During GC, the JVM deallocates objects that are not used by the program anymore. Also depending on the GC algorithms, objects are moved within the heap memory space to perform compaction and avoid fragmentation. Furthermore, the GC overhead is proportional to the size of heap memory we allocate for our Java program. 

So as developers we have a lot of control over our application’s performance by controlling the object allocation in our program. The biggest mistake I hear from Java developers is “memory allocation is fast nowadays so we shouldn’t care about it”. Yes, allocations are cheap, but Garbage Collection is NOT.

Avoiding object allocations if possible is one way to go about it. But another very effective technique is called object pooling.

Basically, if you find yourself allocating an immutable object with the same data over and over again, you can simply allocate it once and cache it for subsequent usages.

Some common examples and candidates for object pooling are:

1. Memory buffers

2. Thread pools

3. Connection pools

4. Dynamically constructed Strings

The logic here is simple. The fewer objects you allocate, the less frequent GC cycles are, and the shorter they are. 

2. Keep Class Methods Short

If you were not convinced by now that keeping your methods short and readable is a good idea, here is another incentive for you. Keeping methods short will make your Java application faster.

As mentioned at the beginning of the article, Java is an interpreted language by default. Once the program is launched, the JVM is keeping stats for every method execution. Once certain thresholds are met, the JVM compiles those methods into machine code and stores them in memory. This is called Just In Time (JIT) Compilation. The more isolated your methods are, the more likely you are to reuse them in your application, and the faster it is for the JVM to detect that the method is worth compiling. When a method is complied into native code it goes through many optimizations that are determined by the JIT compiler based on the previous executions of the method in the interpreter mode. This results in a huge speedup and a much more efficient code.

Very large methods (the values depend on the JVM) will never be JIT compiled by the JVM and will forever remain interpreted.

But that is not all. Calling a method has its own overhead. Storing the local variables and jumping to another method, then restoring the local variables and retrieving the result is not cheap. For that the JVM has another optimization call inlining. 

Inlining is when the code within a method is simply copy-pasted into every place where the method is called. This way the overhead of calling a method is entirely eliminated.

Small methods are excellent candidates for inlining by the JVM. Longer methods are less likely to be considered for inlining and method above certain thresholds (depending on the JVM) will not be considered at all.

So follow programming best practices and keep your methods short.

3. Multithreading and Concurrency

By default, each Java application has only one thread of execution. In other words, our application is executed sequentially, instruction by instruction. But when we have independent parts in our application that can be executed in parallel, we can improve our application's performance by a factor of x2, x4, x8, x16 and even more depending on the hardware our application is running on.

Java and the JVM support Multithreading both as part of the JDK and internally, so by allocating pieces of our code to run on different threads we can achieve great speed up.

There are many benefits to multithreading, including a hidden one that I talk about in this article.

The drawback of multithreading and concurrency is the complexity involved in writing correct, performant, and maintainable concurrent code.

The appeal of multithreading is undeniable. Doubling or quadrupling your performance and saving huge operational costs to your company should drive any good developer to take advantage of it. And rightfully so.

But what often happens is multithreading brings unintuitive bugs and issues like deadlocks, live-locks, race conditions, and data races into our program. 

Defensive programmers often tend to overuse locking and synchronization as well as incorrectly use other concurrency primitives in the effort to avoid such issues. That often erases any speed up you were hoping to achieve through multithreading, making the application overly complex and sometimes even slower.

So my advice with multithreading is either use it wisely or don’t use it at all.

If you take the effort to learn it you can achieve tremendous performance and responsiveness so going the extra mile to master it really pays off.

Java Multithreading, Concurrency & Performance Optimization is a course where you can learn all of that, and it takes no more than about 4 hours to complete.

In this course, you will learn how to systematically optimize your Java application’s performance using multithreading, eliminating any guessing or uncertainty. It takes you through topics like Operating Systems fundamentals, memory organization, as well as covers advanced topics like lock-free algorithms, optimizing for latency and throughput, and much more. Check out the course to learn more.

More Articles

When we think of the benefits of multithreading in Java, the following two often come to mind: 

1. High performance through parallel execution.

2. Multitasking achieved through concurrency.

The benefit of high performance translates directly into money, since fast and efficient applications consume fewer resources and therefore require less expensive hardware or fewer cloud instances.

Multitasking achieved through multithreading allows us to execute multiple tasks within an application instance, which results in high responsiveness of user-interfacing applications.

If you want to learn how to create threads and achieve high performance with Java, click here.

However, there is a third benefit to multithreading that is often overlooked. That is task isolation. Each thread execution in the JVM is isolated from the other threads within the same process.

Although threads within the same process share many resources, a thread has very limited ability to interfere with other threads within the process. This is beneficial because aside from a few specific exceptions, a crashed or a misbehaving thread will not bring down the entire application, let alone other threads.

For example, if a thread dies due to an I/O exception or even a NullPointerException, other threads remain unaffected.

To illustrate the power of thread isolation, let's consider the architecture of a video streaming application:

In this application, data is received from the network by the data capturing thread. Audio is captured from the microphone using the audio capturing thread. And video is captured from an external camera by the video capturing thread. The three data streams are synchronized based on their timestamps by the synchronization thread and later are independently streamed to a live audience as well as saved to a file which can be watched at a later time.

Since each task is isolated in a separate thread, if we lose one of the sources like the data or the audio for example, the rest of the media will continue being broadcasted and saved to the file.

Similarly if the streaming thread crashes, the file saving thread will continue saving the unified media into the file.

The exceptions to the threads isolation rule are:

1. When other threads depend on the misbehaving thread to continue their own work or to finish their calculation.

2. When the error that brought down the thread affects shared resources or the entire process, like in the case of an OutOfMemoryException.

If you want to learn how to create threads and achieve high performance with Java, click here.

When either of those happen, the application is rarely recoverable and often requires a restart.

In the example above, the isolation breaks if the synchronization thread crashes, since the streaming and file saving threads depend on it.

Those problems can be mitigated by a few multithreading architectural tricks. For example, a watchdog thread can monitor the synchronization thread’s health and in an emergency situation may either:

1. Launch another synchronization thread to take its place.

2. Start dumping the input data video and audio to the disk as independent backup files so they can be recovered in the future.

Another vulnerability in this type of architecture is the shared queues that feed the data, video and audio from their capturing threads into the synchronization thread. If those queues grow to a point where our process runs out of memory and we get an OutOfMemoryException, our application can get into a corrupted state.

However, if we implement this multithreaded “multi-producer, multi-consumer” architecture with the right coordination and back pressure techniques, all of which are covered in depth in the Java Multithreading, Concurrency and Performance Optimization course, all these problems can be avoided.

Java multithreading is one of the most powerful tools in any Java developer and software architect's toolkit. It can save us a lot of money on infrastructure, bring superb user experience to our clients, and as we learned in this article allows us to build fault-tolerant applications using thread isolation.

If you want to learn how to build your own highly performant multithreaded applications, take our Java Multithreading, Concurrency and Performance Optimization course.

More Articles

Challenges of Distributed Systems

Distributed Systems pose many challenges. They involve many instances of different applications or services, running on different machines and communicating with each other through the network.

Network failures and network partitions are only part of the problem.

In a typical modern distributed system we can have multiple services calling each other to complete a task. This creates a very dangerous synchronous dependency between a chain of services, while each one can go down at any moment.

There are many reasons while an application may go down in a distributed system.

One of the reasons is pure probability. Even the most reliable hardware breaks, and the more computers we have the higher the probability is that some component will break any moment. Software failures due to exceptions or bugs are even more common. But even aside from failures, some downtime is necessary to roll out a new release or upgrade the operating system. This is where Apache Kafka comes in.

Introduction to Apache Kafka

Apache Kafka is a distributed message broker that allows services to exchange messages without the need for both services to be online and available at the moment of the exchange. Apache Kafka can sit in between services and act as a virtual buffer. You can think of it as a distributed message queue on steroids.

An abstraction that Kafka uses for publishing messages is called a Kafka Topic. Services can publish messages to a Kafka topic and consume messages from a Kafka topic.

Each topic can be further broken down into partitions. Messages within the same topic’s partition are ordered but there’s no global order of messages within a Kafka topic as a whole.

Also, unlike direct HTTP requests that have a single sender and a single receiver, messages to Kafka can be broadcasted to multiple consumers, which follows the common pub/sub pattern.

Benefits of Apache Kafka for Distributed Systems

To ensure reliable delivery, high availability and scalability, Apache Kafka is designed as a distributed system on its own from the ground up.

It uses all the state-of-the-art modern techniques for building fault-tolerant and high-performance applications and distributed databases that power the top e-commerce, search, video on demand, and ride-sharing companies as well as cloud services. 

Reliability

The reliability of Apache Kafka is very configurable. It can be used to deliver mission critical financial events like money transactions with strong guarantees on its delivery semantics. But it can also be used for delivery of logs and metrics that require a lot less reliability and can save on operational overhead

Scalability and Performance

Apache Kafka can scale to 10 GBps of throughout with under 10ms of latency which is one of the reasons 80% of fortune 100 companies use Apache Kafka in production. And thanks to the partitioning of each Kafka Topic, Kafka supports high concurrency both for producers and consumers.

Integration with Client Code Base

Apache Kafka also supports client libraries in languages like Java, C/C++, .NET, Python, Go and many others. This allows software teams to develop services the language of their choice and allow easy integration with Kafka, both for publishing messages to Kafka and consuming messages from Kafka.

If you want to learn how Kafka achieves its high availability and scalability so you can apply the same techniques for your system, check out Distributed Systems & Cloud Computing with Java. In this course you will learn all the fundamentals of modern Distributed Systems and Cloud Computing as well as the practical application of Apache Kafka for your business. The course is targeted towards Java developers and covers a variety of open source technologies like Apache Zookeeper, Distributed MongoDB, HAProxy and many others.

More Articles

Multithreading helps us write software that can interact efficiently with the user and the IO devices such as the network, the disk, keyboard, mouse and others. Most computers today have multiple cores. Multithreading allows us to utilize the full performance capabilities of our computer by running tasks completely in parallel on multiple cores in the same time.
A correct multithreading model for your particular application can improve performance by an order of magnitude, and make it much easier to scale your code and keep it maintainable.

Building the multithreading boiler plate code, for every single application is tedious and error prone, and keeping it reusable for future projects is a full time job. That is why some people made it their full time job, and created some amazing, reusable projects so YOU can use your multithreading knowledge to pick the right technology and decide how to use it, rather than writing your own solution every single time.
Let’s look at the top 3 innovative projects that made software concurrency easy for all of us.

1. Vert.x

Based on Netty, Vert.x is one of the most versatile toolkits for writing high performance multithreaded code. It is both easy to use and completely non-opinionated.
It doesn’t put your code into a frame (therefore it is not a framework), but rather provides you with many easy, non intrusive ways to write your multithreaded code.

Vert.x comes with separate modules for anything you need, and is based and relies on the core module for everything.

A few examples are

• Vert.x Web and Vert.x Web Client modules for HTTP server and client application development.
  MongoDB client and Redis Client for data access.

• Reactive Streams for back pressure and working with streams of data.

• Vert.x Service Discovery and Vert.x Circuit Breaker for managing communication between microservices

• And many other

The main concept of Vert.x is the Verticle which is essentially an event loop running on a single thread. An event loop is an infinite loop that

1. Checks for IO events coming from the OS (in most operating systems it’s done in constant time)

2. Checks for our own scheduled events’ completion (such as timers),

3. Runs all the callback functions registered for incoming events.

4. And goes to the next iteration

For those familiar with NodeJS, this is exactly the same concept. This is called the Reactor Model.

The second main concept Vert.x is advocating for is completely asynchronous, non blocking programming.

Essentially every time you catch yourself writing blocking code like Thread.sleep(1000) or networkDataStream.readLine() you are doing it wrong. (With respect to Vert.x)
In general the problem with writing blocking code is the thread becomes blocked and unusable until that method unblocks. If you still have data coming in from somewhere, you will end up creating more threads to handle that data, and then block those threads again. The more threads you create, the more management work your OS is doing, and less CPU left for us. (Thrashing)
Vert.x provides us with all the tools to write non blocking code and avoid such a situation. So you will need to create only a handful of threads and no more.

For example instead of Thread.sleep(1000) , in Vert.x you write:

long delay = 1000;
long timerId = vertx.setTimer(delay, timerId -> { 
  System.out.println(“This code is triggered after 1000 ms”); 
});

This way you simply register a callback to be executed after the delay has passed, but the thread is never blocked.

If you write all your code in a non blocking, asynchronous way, all you need is a small number of threads, each thread with a single Verticle (Event loop). That pattern is called a Multi Reactor.

Creating Verticle threads with Vert.x is easy.
All you need to do is

1. Extend the abstractVerticle class.

2. Put your code in the start() method

3. Deploy your verticle.

public class CustomVerticle extends AbstractVerticle {

  // This is called when the verticle is deployed
  public void start() { 
    //Your code goes here
  }
}
...
Vertx vertx = Vertx.vertx();
CustomVerticle customVerticle = new CustomVerticle(); 
vertx.deployVerticle(customVerticle);

Creating an HTTP server that runs on 8 threads is just as easy:

public class WebServerVertcile extends AbstractVerticle {
 
  public void start() { 
    HttpServer server = getVertx().createHttpServer(); 
    server.requestHandler(request -> {   
        // Code that handles the requests
    });
    server.listen(8080);
  }
}
...

Vertx vertx = Vertx.vertx();
DeploymentOptions options = new DeploymentOptions().setInstances(8); 
vertx.deployVerticle("WebServerVerticle", options);

That’s it. That is all the code you need!!

Vert.x also supports RX Java, Fibers, programming using the Actor Model and many other ways for you to write your multithreaded code. If you still need to write blocking code, Vert.x provides with ways to do that too.

Supported languages: Java, JavaScript, Groovy, Ruby, Ceylon, Scala and Kotlin.

2. LMAX Disruptor

LMAX Disruptor comes from LMAX Exchange which is a foreign exchange trading facility, based in London. To achieve low level and high throughput, so important for financial trading, LMAX focused on the area of optimizing the queues which pass data in between stages of the system.

Although created initially for financial trading, LMAX Disruptor aims to be a general purpose framework for solving the concurrency problem.

LMAX Disruptor is extremely cache efficient and lock free, which comes with very high performance benefits.

Here are some impressive performance numbers.

In the heart of LMAX Disruptor is an extremely hardware efficient Ring Buffer, which serves as the vehicle for moving events from producers to consumers.

To pass an event from a producer to consumers you need to claim a sequence number in the Ring Buffer. After claiming the sequence number you produce the desired event and publish it to the consumers:
Lets start with creating the producer and consumer classes:

Producer:

public class CustomEventProducer {
  private final RingBuffer<CustomEvent> ringBuffer;
  public CustomEventProducer(RingBuffer<CustomEvent> ringBuffer) {
    this.ringBuffer = ringBuffer; 
  }
  public void publishDataToConsumer(String data) {
    long sequence = ringBuffer.next();  
    try {
      CustomEvent event = ringBuffer.get(sequence); 
      event.set(data);  
    } finally {
      ringBuffer.publish(sequence);
    }
  }
}

Consumer:

public class CustomEventProducer {
  private final RingBuffer<CustomEvent> ringBuffer;
  public CustomEventProducer(RingBuffer<CustomEvent> ringBuffer) {
    this.ringBuffer = ringBuffer; 
  }
  public void publishDataToConsumer(String data) {
    long sequence = ringBuffer.next();  
    try {
      CustomEvent event = ringBuffer.get(sequence); 
      event.set(data);  
    } finally {
      ringBuffer.publish(sequence);
    }
  }
}

Unlike Vert.x that uses the Netty event loop and threading model, LMAX Disruptor is using the general Java Executors for creating the threads.

You could create a simple executor like so

Executor executor = Executors.newCachedThreadPool();

And pass that executor into the LMAX Disruptor

Disruptor<CustomEvent> disruptor = new Disruptor<>(CustomEvent::new, BUFFER_SIZE, executor);

Now all we need to do is create a producer and a consumer and pass the consumer into the disruptor.

RingBuffer<CustomEvent> ringBuffer = disruptor.getRingBuffer();
CustomEventProducer producer = new CustomEventProducer(ringBuffer);
CustomEventConsumer consumer = new CustomEventConsumer();
disruptor.handleEventsWith(consumer);

Start the disruptor and produce data

disruptor.start();
producer.produce("Some piece of Data");

That’s it!

If your application is designed to be performed in stages, such as a transformation pipeline, LMAX Disruptor will do it the most efficiently for you, and it leaves the threading boiler plate to the Java standard Executors which comes in many flavors and configurations.

Supported languages: Java, .Net (Port of LMAX Disruptor)

3. Akka

Akka aims to make it easy for developers to write concurrent, message driven applications and is based on the Actor Model.

In that model you decouple your code into actors that maintain state and act on your data. The actors communicate with each other through messages that they send to each other’s “mailbox”.

The actors are arranged in a hierarchical structure where each actor has exactly one supervisor. And the overall master actor takes the original work and splits it among its children/worker actors. This way each actor is responsible for only one task. And if the actor fails to perform that task, he can asks his supervisor for help.

Similarly to Vert.x, Akka’s actors should not block the thread.

In addition, actors should not pass any mutable objects between each other. This way no synchronization between threads is needed, and each actor thread can operate on its data without contention with other threads.

Unlike Vert.x and LMAX Disruptor that aim to provide the developers with control over threading to achieve the desired performance, Akka is aiming to abstract the multithreading from the developer almost entirely, making it easy to focus on the logic and stay worry free about concurrency as long as you follow Akka’s best practices.

To get the ball rolling with Akka, more boiler plate code is needed than with LMAX Disruptor or Vert.x, but the idea is pretty straightforward.

Every actor has to extend the UntypedActor class and implement the public void onReceive(Object message) method which is called when an actor receives a message.

An example for a typical actor:

public class WorkerActor extends UntypedActor {
  @Override
  public void onReceive(Object message) {
    //handle message and send a message to another actor
  }
}

Besides creating the actor classes, we also need to define the message class for every actor to actor communication.

So for example if we have a master actor and a worker actor, and the master actor wants to pass a task to the worker, and get a result back, the general structure would be like this:

public class MasterToWorkerMessage {
  private final String message;
  public MasterToWorkerMessage(String message) {
    this.message = message; 
  }
  
  public String getMessage() {
    return message;
  }
}
public class WorkerToMasterMessage {
  private final String result;
  public MasterToWorkerMessage(String result) {
    this.result = result; 
  }
  
  public String getResult() {
    return result;
  }
}

And the worker class would like like this

public class WorkerActor extends UntypedActor {
  ...
  @Override
  public void onReceive(Object message) {
    if(message instanceof MasterToWorkerMessage) {
      MasterToWorkerMessage work = (MasterToWorkerMessage)message;
      String result = calculateResult(work.getMessage());
      getSender().tell(new WorkerToMasterMessage(result), 
                       getSelf());     
    }
    else {
      unhandled(message);
    } 
  }
  private String calculateResult(String message) {
    ...
  }
}

The master class has a little more boiler plate code to set up the router and configure how many children workers to create and how many message to send to each child at a time, but the idea is very simple.

For more information about how to create actors in Java you can follow the official example.

Just like Vert.x, Akka also provides separate modules such as

• Akka HTTP for everything relating to building HTTP servers.

• Akka Streams for back pressure and working with streams of data

• And many other modules for persistence, cluster management, and others

Supported languages : Scala, Java

It's important to note that using either of those projects is not a substitute to knowing core Java Multithreading and Concurrency. And without that knowledge you may easily introduce data races, performance bottlenecks and many other issues so hard to debug and troubleshoot. To master those topics I recommend taking the Java Multithreading, Concurrency & Performance Optimization course which covers all those topics in depth with strong emphasis on high performance and best practices.

Summary

There is no magic bullet and no one framework or toolkit to solve all problems. As software engineers and architects we need to learn the requirements of our system and use our judgment to decide which technology to use and when.

Vert.x is an excellent choice when your application is IO bound and you need to have full control over your threading model.

Lmax Disruptor is most efficient in message passing between stages of your application.

Akka provides great abstraction based on the actor model and immutability, to free developers from dealing with concurrency issues in the first place.

More Articles