Daniel J. Duffy started the company Datasim in 1987
The goal of this advanced hands-on course is to analyse, design and implement customisable and maintainable software systems using state-of-the-art design techniques in combination with object-oriented programming languages such as C++ and C#. We integrate these techniques to produce a seamless and defined process from problem description to working code. We pay particular attention to system decomposition, software design patterns and their implementation. Finally, we discuss the software trajectory for a number of model applications from various domains. These cases can be used as motivation and foundation for your own applications.
The percentage theory/practice is approximately 70/30. Exercises involve designing new compact test cases and determining how to modify existing designs. You have access to the source code of the five test cases that we discuss in Part E of the course. There are also opportunities to write small code samples in C++ or C# and integrate them into the working prototype.
Finally, in this outline we give some examples of the standard visual representations (for example, UML diagrams) that are used in the course to aid in understanding the main topics.
- Scope and manage the project as early as possible.
- Develop a system model and align it with functional requirements and system features.
- Categorise the system to enhance reusability and reduce risk.
- Create a stable system context diagram and proof-of-concept prototype.
- Decompose and refine system components into classes with well-defined interfaces.
- Design and implementation using a combination of object-oriented, generic and functional programming styles.
- Coding in C++ and C#.
- A defined process to design robust and customisable applications.
- Gain insights into software development from architecture through to C++ and C# code.
- Learn multiparadigm software design patterns and extensions to object-oriented software patterns.
- Fully worked test cases in C++ and C#.
- The ability to estimate project size and complexity; manage the project.
- Complete software lifecycle model A-Z.
For whom is this Course?
This is an advanced course for experienced software developers, designers and architects who wish to create libraries, frameworks and applications for medium and large software projects.
If you are interested in taking this course (in original or customised form) please contact us at email@example.com
There are ample opportunities to interact with the trainer and with the other attendees in order to promote understanding of the topics in the course.
A. System Scoping
This is the first stage of the software project and the main goal is to understand the problem that we are trying to solve before we start on a design of the corresponding software system (which we call SUD or System Under Discussion). In particular, we wish to understand what the system to be developed must deliver and to this end we first determine what the boundaries of the system are. We achieve this end by identifying the external systems with which SUD exchanges information and data. Then we integrate the system requirements and desired features with the system model.
The products from this stage are:
- A context diagram comprising SUD and its satellite systems.
- Each system has well-defined responsibilities; system services have been identified.
- System requirements and features aligned with the systems in the context diagram.
- System goals and core process
- Major data flow; linking major output to input
- Discovering external systems
- Initial context diagram
Sample Context diagram
System Requirements and Features
- Viewpoint-oriented requirements determination
- Interviewing techniques and requirements elicitation
- Functional and non-functional requirements
System Responsibilities and Services
- What is a system service?
- Provides and requires services
- Assigning services to systems
- Documenting services
Proof-of-Concept I: Feedback from Domain Experts
- Getting critical early wins and results
- Major data flow
- Initial (numerical) examples
- Reaching consensus with the system architect
- Initial mission design blueprint
Proof-of-Concept II: Prototype
- What do we wish to achieve?
- Viewpoints: architect, designer and project manager
- Creating a prototype
- Review and planning for the next stage
B. Detailed Architectural Design
The products from this stage are:
- Specification of the components of a system and the communication between them.
- Connection architectures: object, interface, plug and socket.
- Discovering reusable components using Domain Architectures and Architectural Styles.
- Pay some attention to multitasking programs and parallel programming systems.
- What is a domain architecture?
- Behavioural and structural properties
- The big five categories (MAN, ACS, RAT, PCS, MIS)
- Analogical reasoning and system discovery
Acces Control System
- Design vocabulary and allowed structural patterns
- Computational model; relationship with Domain Architectures
- Examples (categories) and specialisations
- Basis of Communication (shared state, events)
- Task and data decomposition
- Data dependency graph
- Concurrency versus parallelism
- Coarse-grained and find-grained parallelism
Component Connection Architectures
- System specification
- Provided and required behaviour features
- Conforming components
- Configuring an architecture
C, System Decomposition Patterns
The goal of this stage is to carry out a detailed decomposition of system components into more fine-grained modules and objects. We address the full lifecycle from the object creation process to defining object structure and the desired level of behavioural flexibility. We decompose the components to a stage whereby it is possible to begin with the detailed design of classes and modules as well as determining the level of flexibility that they should satisfy.
The products from this stage are:
- A detailed overview of the most important system and parallel design patterns.
- Decompose logical components into more fine-grained objects.
- System assembly using assemblies, static and dynamic link libraries.
High-impact of Systems Patterns
- (Super) Builder and sub-contractor factories
- Whole Part and Composite
- Statecharts and state machines
Parallel Design Patterns
- Divide and Conquer
- Geometric Decomposition
- Event-based coordination
The Actor Model
- What is an actor?
- The message-passing model; message blocks
- Sources and targets
- Starting and stopping an actor-based application
Configuration, Packaging and Lifecycle Specification
- Assemblies, static libraries and dynamic link libraries
- Lifetime management of multi-levelled domain architectures
- Metadata and reflection patterns
- Maintainability and version control
D. Modern Software (GOF) Design Patterns Process
The main goal of this stage in the software project is to create the detailed design blueprints that are used as input to programming activities using a multiparadigm style in languages such as C++, C# and Java. We commit to a given language and specific interface implementation. We also pay attention to reusability issues by determining if we can use standard libraries instead of creating home-grown code. Finally, we need to determine the levels of portability, maintainability and efficiency that the software modules, classes and components should satisfy.
The products from this stage are:
- Design blueprints that can be directly implemented in order to produce a working prototype.
- Plans for the next prototype (allocation of resources).
- Discovering new, evolving and missing requirements.
- Inheritance and composition
- Aggregation and association
- What constitutes a good object model?
- Object-oriented software metrics
Structural Design Patterns
- Strategy and Template Method
- Next-generation Observer and Delegates
- Role (Facet) pattern
D. Test Cases and Model Problems
In this section we examine a number of ready-to-run applications from various domains to show how we applied the design principles and software patterns that we discussed in this course. The applications have common features but each one has its own particular requirements that need to be satisfied.
Environment controller (Process Control)
- Product vending machine (Access Control)
- Customer helpdesk (Resource Allocation and Tracking)
- Extended builders (Manufacturing)
- High-level reporting (Management Information)
- Environment controller (Process Control)
Daniel J. Duffy started the company Datasim in 1987 to promote C++ as a new object-oriented language for developing applications in the roles of developer, architect and requirements analyst to help clients design and analyse software systems for Computer Aided Design (CAD), process control and hardware-software systems, logistics, holography (optical technology) and computational finance. He used a combination of top-down functional decomposition and bottom-up object-oriented programming techniques to create stable and extendible applications (for a discussion, see Duffy 2004 where we have grouped applications into domain categories). Previous to Datasim he worked on engineering applications in oil and gas and semiconductor industries using a range of numerical methods (for example, the finite element method (FEM)) on mainframe and mini-computers.
Daniel Duffy has BA (Mod), MSc and PhD degrees in pure and applied mathematics and has been active in promoting partial differential equation (PDE) and finite difference methods (FDM) for applications in computational finance. He was responsible for the introduction of the Fractional Step (Soviet Splitting) method and the Alternating Direction Explicit (ADE) method in computational finance. He is also the originator of the exponential fitting method for time-dependent partial differential equations.
He is the originator of two very popular C++ online courses (both C++98 and C++11/14) on www.quantnet.com in cooperation with Quantnet LLC and Baruch College (CUNY), NYC. He also trains developers and designers around the world. He can be contacted firstname.lastname@example.org queries, information and course venues, in-company course and course dates.
Duffy, D.J. (2004) Domain Architectures, Wiley Chichester.
|Date from||Date to||Location||Price (excl. VAT)|
|Wednesday 5 September 2018||Friday 7 September 2018||Amsterdam||EUR 2150.00|