- Agile Strategy
- API Integration
- Application Architecture
- ArchiMate
- Artificial Intelligence
- Brain-Inspired Architecture
- Cloud
- Cloud Computing
- Data Architecture
- Design
- DevOps
- Digital Transformation
- Domain-Driven Design
- Enterprise Architecture
- Governance
- Innovation
- Memristors
- Methodology
- Microservices
- Microservices Design
- Modeling
- Neuromorphic Computing
- Project Management
- Roles
- Scrum
- Software Architecture
- Solution Architecture
- Spiking Neural Networks
- Strategy
- Technology Architecture
- TOGAF
Les articles concernant Design
The Fundamental Principles of Domain-Driven Design (DDD)
Introduction
As software systems grow increasingly complex, it becomes essential to design architectures that accurately reflect business needs. That’s the core goal of Domain-Driven Design (DDD), an approach introduced by Eric Evans in 2003 that places the business domain at the heart of software design.
DDD is more than a modeling method—it’s a design philosophy that deeply influences application architecture by guiding component structure, responsibility definition, and system communication.
This article explores the 10 fundamental principles of DDD, with concrete examples and architectural impacts, especially in microservices contexts.
Application Architecture: Designing Robust and Adaptable Systems
Introduction
In a constantly evolving digital landscape, user requirements and technological constraints proliferate. A thoughtful application architecture does more than organize code: it defines a holistic strategy to decouple responsibilities and optimize performance, scalability, and resilience. This engineering discipline is essential for organizations aiming to stay competitive and agile.
Foundations and Definitions
Application architecture encompasses the rules, components, and interfaces that structure an application. It includes:
- Separation of Concerns: Breaking the application into modules or layers with clear responsibilities to simplify understanding, testing, and maintenance.
- Modularity: Designing independent, reusable components that can be deployed and updated in isolation.
- Design Patterns: Applying proven models—such as Model-View-Controller, layered architectures, or microservices—to standardize and streamline software structure.
Together, these principles enable flexible environments where technical evolution and functional changes integrate smoothly.
Application Architecture – Context
Are You Concerned with Application Architecture?
If you’re a developer, you want to understand how application components interact; how a particular application workflow should run and what results to expect; and how an end user should engage with an input or display screen.
If you’re an infrastructure specialist, you need to know the type and volume of data stored and transferred; the frequency and load each application process demands; and how different application solutions fit together within the information system (IS).
AWS vs Azure
Opinion – Comparing the Cloud Computing Giants
KINSTA is an American WordPress hosting provider that publishes in-depth blog articles on various themes. While reading “AWS vs Azure in 2021 (Comparing the Cloud Computing Giants),” I discovered several interesting insights to share.
Cloud Computing Players
The rapid growth in cloud demand has spawned an exponential increase in services and options. The broader your target, the more use cases you must support and the more products you need to offer.
Differences Between TOGAF and ArchiMate
Answering the question of the differences between TOGAF and ArchiMate is not straightforward, but here’s what you need to know.
Most organizations today are embarking on or renewing their enterprise architecture practices. Is yours part of that trend?
If so, you’re not alone—many enterprise architects are confused by the distinctions between TOGAF and ArchiMate. While there are overlaps, each standard serves a distinct purpose. Which one should you learn first?
Which Application Architecture to Choose
Choosing an Application Architecture is a pivotal decision impacting team structure, workflows, technology choices, skill requirements, and interactions with internal users, clients, and partners. So, which application architecture in 2021?
Preface
This article focuses not on technology vendors or platforms but on architectural choices. Given the multitude of technical solutions across diverse scenarios, covering them all in one piece is impossible. Future posts will address specific technologies, which are equally important.
Solution Architecture – Designing Around a Specific Problem
Solution Architecture is the least well-defined component of Enterprise Architecture. In other words, the same term can encompass activities with differing scopes. Yet demand for Solution Architects continues to grow, highlighting the role’s rising importance. Let’s clarify its contours.
What Is Solution Architecture?
According to Gartner, Solution Architecture is the architectural description of a specific solution—a coherent and sufficient set of features that addresses a defined set of requirements.
The Scaled Agile Framework (SAFe) describes Solution Architecture as defining and communicating a shared architectural and technical vision for work in progress.
Technology Architecture or Technical Architecture vs Technical Expertise
Beyond the terms that may vary from one organization or methodology to another, it’s essential to understand what defines Technology Architecture (or Technical Architecture) and what distinguishes it from Technical Expertise.
It’s therefore necessary to separate governance roles from implementation roles. Both are crucial, and individuals can navigate between them over the course of a career.
Within Enterprise Architecture, Technology Architecture focuses on functionality—data persistence, executing workloads tied to a business process, and so on. Its goal is to organize, standardize, and govern the use of technologies in implementing the Application Architecture.