Hands-on Software Engineering provides practical resources for learning and applying modern software engineering principles, methods, and best practices. The site emphasizes systematic processes, clear guidelines, concrete examples, and reusable resources that help students, practitioners, educators, and researchers apply software engineering concepts to real-world systems.

The contents are organized around our published and forthcoming books and currently focus on three major areas:

• Hands-on Software Architecture: Unified Architecture Process
• AI Systems Architecture: Predictive, Generative, Agentic, and Physical AI
• AI-Assisted Object-Oriented Programming: Generation, Review, and Refactoring in C++, Java, and Python

These resources are primarily designed to support the development of large-scale conventional and AI-based software systems, where systematic engineering processes, sound design principles, and disciplined practices are particularly important. Each area combines conceptual foundations with hands-on methods, examples, templates, case studies, and supporting materials for practical application.

---

What is Software Architecture?

Software architecture is a critical design activity in modern software development, providing the structural foundation for building reliable, scalable, maintainable, and evolvable software systems. Its importance becomes even greater in large-scale, industrial-strength applications, where complexity, performance requirements, integration demands, and quality attributes introduce significant design challenges.

Software architecture addresses the organization of a system into major elements, their responsibilities and interactions, architectural views, and design decisions that influence both functional and non-functional requirements. A well-designed architecture provides a stable foundation for subsequent design, implementation, integration, deployment, and evolution.

Why a Systematic Architecture Methodology?

Designing software architecture is a complex activity that requires more than individual experience or ad hoc design decisions. A systematic architectural methodology provides the structure needed to guide architects from requirements understanding through architectural formulation, refinement, and evaluation.

Such a methodology defines clear activities, work products, decision points, and architectural views. It also provides systematic ways to address architectural styles and patterns, quality attributes, design rationale, and scenario-based evaluation. This disciplined approach improves consistency, traceability, repeatability, and justification of architectural decisions, while helping ensure that the resulting architecture remains aligned with system objectives.

Unified Architecture Process (UAP)

The Unified Architecture Process (UAP) provides a comprehensive methodology for applying this systematic approach in practice. UAP organizes software architecture design into well-defined activities, work products, and architectural views that progressively transform requirements into a coherent architectural solution.

UAP integrates requirements refinement, system context analysis, schematic architecture design, architecture views, design for non-functional requirements, and architecture evaluation within an iterative and disciplined workflow. It also incorporates architectural styles and patterns, quality-related design strategies, rationale documentation, and scenario-based evaluation to support systematic architectural decision-making.

By providing a structured and repeatable process, UAP helps architects develop architectures that are traceable, justifiable, adaptable, robust, and aligned with both functional and non-functional system requirements.

---

AI Systems Architecture: Predictive, Generative, Agentic, and Physical AI

What are AI Systems?

An AI system is a software system whose intelligent functionality is provided by models, whose behavior is learned from data rather than specified by developers. In addition to its models, an AI system contains non-model components such as data pipelines, knowledge and retrieval stores, serving infrastructure, orchestration logic, monitoring, and user-facing applications, which interact through pipelines, request–response exchanges, and control loops.

AI systems differ in architecture not by what their models compute but by the position of the model in the system, characterized by three dimensions: model provenance, control locus, and action domain. These dimensions distinguish four classes of AI systems:

• Task-Specific Model Systems: system-owned models within designer-defined control flow, such as forecasting, anomaly detection, and recommendation systems
• Foundation Model Systems: externally provided models adapted by prompting, retrieval, or fine-tuning, such as enterprise assistants and generative applications
• Agentic AI Systems: control determined at runtime by models that plan, invoke tools, and coordinate with other agents
• Physical AI Systems: systems that act on the physical world through sensors and actuators under timing and safety constraints, such as robots, autonomous vehicles, and embodied assistants

Each class retains the concerns of the preceding one and adds its own, and many practical systems are hybrids that combine several classes under a dominant one.

Why Architecture for AI Systems?

AI systems raise engineering challenges that conventional software systems do not: behavior that is learned rather than fully specified, dependence on data quality and representativeness, uncertain and variable outputs, limited interpretability of model behavior, decisions delegated to models, error propagation through composed models and agents, and the continuous evolution of models and data.

Most of these challenges cannot be resolved inside the model. They are addressed by the structure of the system around it, through validation and guardrail components, fallback paths, human oversight, monitoring, evaluation gates, and controlled release. Software architecture is therefore the principal means of making AI systems reliable, safe, trustworthy, and maintainable, with quality attributes serving as the criterion for architectural decisions.

Architecting AI Systems

AI systems architecture concerns the components, connectors, views, quality attributes, tactics, patterns, and reference architectures by which a system containing one or more models is structured, evaluated, and sustained. Its subject is the system around the model rather than the model itself.

The conventional architectural views are revised for AI systems, and two views are added: the Intelligence View, which describes how the system realizes its intelligent functions, and the Learnability View, which describes how the system learns and releases improved behavior. Quality attributes are treated as retained, redefined, or added for AI systems, with trustworthiness as a composite attribute. For each class, a reference architecture, quality-attribute design tactics, and a catalog of architecture patterns guide the derivation of a system-specific architecture.

About the Book

The forthcoming book AI Systems Architecture: Predictive, Generative, Agentic, and Physical AI presents a systematic treatment of architecting the four classes of AI systems. It is organized in seven parts: foundations; one part for each class, covering its reference architecture, sub-architectures, quality-attribute design, and a complete case study; cross-class practices, including architecture evaluation, evolution and operations, security, governance, and hybrid systems; and a catalog of architecture patterns.

The case studies cover an expense anomaly detection system, an enterprise policy assistant, an employee travel assistant, and an embodied learning companion. This website will provide supplementary resources, including view templates, checklists, and case-study materials, to support courses, self-study, and professional practice.

---

AI-Assisted OOP: Generation, Review, and Refactoring

Why Programming in the AI Era?

As AI copilots increasingly generate code from natural-language prompts, it may seem that traditional programming skills are becoming less important. In reality, programming knowledge is more important than ever. AI can rapidly produce candidate solutions, but it cannot reliably determine whether the resulting code is correct, well designed, secure, maintainable, or appropriate for a particular system context. Developers must still understand the problem, express design intent and constraints, evaluate alternatives, identify weaknesses, and validate that the software satisfies its requirements.

Programming knowledge therefore provides the foundation for using AI effectively. Skilled developers know what to ask for, how to assess generated code, and how to refine it when necessary. Programming also develops disciplined problem-solving skills, including decomposition, abstraction, logical reasoning, and systematic design. In the AI era, the programmer’s role is evolving from writing every line of code manually to guiding, evaluating, and improving AI-generated solutions through effective human–AI collaboration.

Why OOP Constructs Matter

A sound understanding of object-oriented programming constructs is essential because they provide the foundation for designing, analyzing, and implementing object-oriented software. Constructs such as objects, classes, inheritance, polymorphism, dynamic binding, abstract classes, interfaces, generic classes, and reflection enable developers to realize abstraction, encapsulation, reuse, extensibility, and flexible software structures. This understanding is even more important in AI-assisted programming, where developers must be able to judge whether AI-generated code applies OOP mechanisms correctly, assigns responsibilities appropriately, and produces maintainable and extensible designs. Without a solid grasp of these constructs, developers cannot reliably evaluate, refine, or validate AI-generated object-oriented code.

AI-Assisted OOP Practices

AI copilots can significantly enhance object-oriented programming by supporting three major activities: code generation, code review, and code refactoring. However, effective AI assistance requires developers to provide clear programming intent, design constraints, and evaluation criteria rather than relying on unconstrained code generation.

Structured copilot prompt templates help make these interactions more precise, systematic, and repeatable. Through this human–AI collaboration, developers remain responsible for guiding the copilot, evaluating its outputs, refining the generated solutions, and validating that the final code satisfies both functional requirements and sound OOP principles.

---

Meet Our Team

We are a team of researchers and practitioners with extensive research, development, and industry experience. Our expertise spans both computer science and application domains, enabling us to address AI and software engineering problems from both technical and domain perspectives.

Key members of the team include the following experts:

• Soo Dong Kim, Ph.D. (Software Architecture, Agentic AI Systems, AI in Healthcare)
  Founder/CEO, PrimeAI Labs LLC, CA, USA
  Emeritus Professor, School of Software, Soongsil University, Seoul, Korea
• Jennifer Jin, Ph.D. (Software Engineering, Machine Learning)
  Associate Professor, School of Computer Science and Engineering, California State University, San Bernardino, CA, USA
• Mira Kim, Ph.D. (Software Engineering, AI Systems Design)
  Assistant Professor, Department of Computer Science, California State University, Fullerton, CA, USA
• Daniel Jin, M.D. (AI Systems for Medical Diagnosis)
  Assistant Professor, Vascular & Interventional Radiology, Loma Linda University Medical Center, CA, USA
• Myong Ho Song, Ph.D. (Software Engineering, Industrial AI Systems)
  Project Manager, Division of Industrial AI, DeltaX Corporation, Seoul, Korea
• Additional contributors specialize in UX design, software development, quality assurance, and back-end engineering.