Tagged articles
Software Modeling
30 articles · Page 1 of 1
This article explains UML 2.5's 14 diagram types, categorizes them into structural and behavioral diagrams, highlights the 7 most frequently used diagrams in daily development (class, sequence, state machine, activity, use case, component, deployment), provides a cheat sheet for selecting the right diagram per scenario, and recommends tools like Mermaid and PlantUML.
MermaidPlantUMLSoftware Modeling
0 likes · 12 min read

The article explains the standards for high‑quality architecture diagrams, outlines common UML diagram types, compares a range of online, professional, and cloud‑native UML tools with pros and cons, and offers practical tips and a step‑by‑step process for creating clear, visually appealing diagrams.
Software ModelingUMLarchitecture diagrams
0 likes · 9 min read

This article explains what UML state diagrams are, why they matter for modeling dynamic system behavior, outlines their core components, and walks through a practical e‑commerce product‑management example with detailed steps and visual illustrations to help developers design robust state‑based models.
Software ModelingState DiagramUML
0 likes · 8 min read

This article explores the essential role of modeling in software engineering, outlines the three main types of modeling, examines why modeling remains a persistent challenge due to language ambiguity and real‑world complexity, and provides practical guidance on business and domain modeling for architects.
Software Modelingarchitecturebusiness analysis
0 likes · 16 min read

This article explains what modeling means across disciplines, why it is essential for simplifying complex real‑world problems, outlines the three main types of modeling in software engineering, and dives into the practical difficulties of business, domain, and data modeling with concrete examples and diagrams.
Business ModelingSoftware Modelingdomain modeling
0 likes · 17 min read

This article explains how Event Storming—a collaborative, sticky‑note‑driven workshop—helps teams break down complex business processes into events, commands, aggregates and policies, dramatically speeding up requirements analysis, improving model quality, and turning the resulting model directly into code and living documentation.
Agile CollaborationEvent StormingSoftware Modeling
0 likes · 14 min read

This article explains how modeling, especially Model‑Driven Architecture (MDA), helps software architects identify and manage complexity by abstracting business, logical, and technical concerns into CIM, PIM, and PSM layers, and provides practical principles for prioritizing architectural decisions.
MDASoftware Modelingcomplexity management
0 likes · 8 min read

This article introduces the basics of software modeling and design documentation, explaining UML diagram types such as class, sequence, component, and deployment diagrams, and outlines how architects use these models throughout requirement analysis, high‑level design, and detailed design, while also promoting a community and related resources.
Software ModelingUMLdesign documentation
0 likes · 17 min read

This article introduces PlantUML, explains its core features, walks through quick setup with IDE plugins, demonstrates basic and advanced sequence diagram syntax—including participants, messages, lifelines, activation bars, groups, notes, and colors—and provides a complete Google‑login example for practical reference.
Diagram ToolsPlantUMLSoftware Modeling
0 likes · 14 min read

This article introduces PlantUML, explains its text‑based diagramming approach, walks through quick setup, IDE plugins, core sequence‑diagram syntax—including participants, message types, lifelines, activation bars, grouping, notes, and color customization—while providing complete code examples and best‑practice tips.
PlantUMLSoftware ModelingUML
0 likes · 12 min read

This article introduces the basics of software design documentation, explaining how software modeling and UML diagrams such as class, sequence, component, deployment, use case, state, and activity charts are used to capture domain problems and system architecture throughout requirement analysis, high‑level design, and detailed design phases.
Software ModelingUMLdocumentation
0 likes · 16 min read

This article explains the fundamentals of software design documentation, covering why modeling is essential, how UML diagrams such as class, sequence, component, deployment, use‑case, state and activity charts are used across requirement analysis, conceptual design, and detailed design phases, and how architects tailor documents for different stakeholders.
Software ModelingUMLdesign documentation
0 likes · 15 min read

This article introduces the fundamentals of software modeling and design documentation, explaining how UML diagrams such as class, sequence, component, deployment, use‑case, state and activity charts are used across requirement analysis, conceptual design, and detailed design phases to create clear architectural blueprints.
Software ModelingUMLdesign documentation
0 likes · 16 min read

The article systematically examines Domain‑Driven Design through four discourses—Structure, Process, Language, and Modeling—while contrasting the practical “folk” school with the academic school, linking philosophical ideas, software‑complexity theory, strategic and tactical design, refactoring, agile practices, ubiquitous language, and its parallels to UML/SysML, arguing DDD repackages existing engineering concepts rather than inventing new ones.
Bounded ContextDDD Strategic DesignDDD Tactical Design
0 likes · 17 min read

This article introduces Data Flow Diagrams (DFD) as a visual tool for modeling system data flows, explains their core components and symbols, and demonstrates their application through a step‑by‑step airline ticket reservation case study, helping readers grasp DFD creation and interpretation.
Airline BookingDFDSoftware Modeling
0 likes · 6 min read

This article explains the concept, components, and basic symbols of Data Flow Diagrams (DFD) and demonstrates how to draw a complete DFD for a ticket‑booking system, illustrating entities, processes, data stores, and data flows step by step.
Software Modelingdata flow diagramticket booking
0 likes · 6 min read

This article demonstrates how to leverage ChatGPT's ability to produce textual code snippets together with PlantUML to automatically create various UML diagrams—such as sequence, class, flow, state, and use‑case diagrams—from Java‑style pseudocode, providing a step‑by‑step workflow and example prompts.
ChatGPTPlantUMLSoftware Modeling
0 likes · 9 min read

This article explains the basic concepts of software modeling, the role of UML diagrams, and how to organize those models into a coherent software design document that guides architects, developers, testers, and stakeholders throughout the development lifecycle.
Software ModelingUMLdesign documentation
0 likes · 14 min read

This article explains the purpose of aggregates in Domain‑Driven Design, illustrates common pitfalls with database‑centric and naïve OO models, and provides practical heuristics and implementation guidelines—including lifecycle, domain, and scenario consistency—to help developers design clean, consistent aggregates.
DDDSoftware Modelingaggregates
0 likes · 22 min read

This article provides a comprehensive overview of UML, explaining its purpose, core elements, diagram classifications, static and dynamic models, and the typical modeling process, enabling readers to understand, create, and interpret UML diagrams across software development stages.
Software ModelingUMLdynamic model
0 likes · 4 min read

The article analyses the rise and fall of UML, tracing its origins in the 1990s, the impact of CASE tools, the shift toward agile development, and the technical and cultural reasons for its decline, while also exploring emerging lightweight modeling alternatives such as C4 and masala diagrams.
CASE toolsSoftware ModelingUML
0 likes · 13 min read

This article explains how software architects can use UML‑based modeling and a series of design documents to capture domain problems and system solutions, communicate functional and non‑functional requirements, and guide development across requirement analysis, architectural design, and detailed implementation.
Software ModelingUMLdesign documentation
0 likes · 14 min read

This article explains what an architecture diagram is, why it matters, and provides a step‑by‑step methodology—including business and system modeling, abstraction techniques, and evaluation criteria—to help engineers create clear, purposeful diagrams for diverse stakeholders.
Software Modelingabstractionarchitecture
0 likes · 29 min read

Clear, layered software architecture diagrams prevent misunderstandings, and the C4 model—covering Context, Container, Component, and Code levels—offers a simple, universal language for visualizing static system structures, guiding teams from high‑level overviews to detailed code maps across diverse audiences.
C4 modelSoftware Modelingdiagramming
0 likes · 8 min read

This article explores practical Domain‑Driven Design in a B‑to‑B setting, comparing data‑centric and object‑centric modeling, illustrating blood‑loss, anemia, and rich models, and showing how dependency injection, testing strategies, repository abstractions, and deployment architectures can improve software quality and maintainability.
Software Modelingbackend architecturedependency-injection
0 likes · 15 min read

This article outlines the ADMEMS approach’s ten essential guidelines for robust graph modeling, covering rules, simplified syntax, discovery of responsibilities, incremental modeling, and practical tips to avoid over‑detailing, helping designers create clear preliminary designs for complex systems.
ADMEMSDesign PrinciplesSoftware Modeling
0 likes · 5 min read

This guide explains UML's core relationship notations, the nine essential diagram types and their purposes, detailed insights into class, object, use‑case, sequence, collaboration, state, activity, component, and deployment diagrams, and how they map to fundamental object‑oriented concepts such as boundary, entity, and control classes.
Software ModelingUMLobject-oriented
0 likes · 14 min read

This article reviews UML basics, corrects earlier mistakes, and provides a practical guide on when and how to apply sequence, component, and state diagrams for effective system architecture modeling.
Software ModelingState DiagramUML
0 likes · 16 min read

This article reviews UML basics, corrects earlier mistakes, and explains how and when to apply sequence, component, and state diagrams—covering their elements, modeling rules, and practical examples—to help architects build clear abstract models.
Software ModelingState DiagramUML
0 likes · 15 min read

This article explains UML as a modeling language, detailing its semantics and notation, and introduces the nine core diagram types—use case, class, object, static, behavior, interaction, implementation, component, and deployment—highlighting their purposes, differences, and how they support static and dynamic system modeling.
Diagram TypesSoftware ModelingUML
0 likes · 10 min read
