Course Overview
|
Course Synopsis
|
Software Architecture and Design introduces the essential concepts of software architecture and design. Both software architecture and design are important phases of software development. The concepts and command to develop a strong architecture and design is essential for developing state-of-the art applications. The course will provide a strong foundation to students for coming up with the skills necessary to develop architecture and realize it in design for developing applications fulfilling both functional and non-functional requirements. Different architectural styles and object oriented design patterns will be taught which will help students to analyze, select and implement design strategies required to realize the selected architecture. Overall course is an essential and great contribution to student’s skills and their software engineering career.
|
Course Learning Outcomes
|
On successful completion of this course students would be able to:
- -Argue the importance and role of software architecture and design in software systems.
- -Develop Architecture and Design for software systems.
- -Recognize major software architectural styles and design patterns.
- -Apply software architecture/design strategies as per the given requirements to build state of art applications.
|
Course Calendar
|
|
|
Week 01
|
1
|
1.1. Design – What and Why
|
|
2
|
1.2. Design – Objectives
|
|
3
|
1.3. Software Design – Complexity
|
|
4
|
1.4. Software Design – Complexity and Size
|
|
5
|
1.5. Types of Complexities
|
|
6
|
1.6. Why is Software Design Hard?
|
|
7
|
1.7. Software Design: A Science Or An Art?
|
|
8
|
1.8. Software Design: A Wicked Problem
|
|
9
|
1.9. Design Process - More Systematic and Predictable
|
|
10
|
1.10. Dealing with Software Complexity: Different Rules and Principles
|
|
11
|
1.11. Characteristics of Software Design
|
|
12
|
1.12. Benefits of Good Design
|
|
13
|
1.13. A Generic Design Process
|
Week 02
|
14
|
2.14. Inputs to the Design Process
|
|
15
|
2.15. Desirable Internal Design Characteristics
|
|
16
|
2.16. What is good design?
|
|
18
|
2.18. Coupling – Design of a Simple Web App
|
|
20
|
2.20. Relationship between Coupling and Cohesion
|
|
21
|
2.21. Software Design Strategies Structured and Object-Oriented Design
|
|
22
|
2.22. Object-Orientation Basic Concepts - The Object
|
|
23
|
2.23. Object-Orientation Basic Concepts - The Class
|
|
24
|
2.24. Relationship between Classes and Objects - Association
|
|
25
|
2.25. Relationship between Classes and Objects: Aggregation and Composition
|
|
26
|
2.26. Relationship between Classes and Objects: Inheritance
|
|
27
|
2.27. Object Orientation Basic Concepts Abstract Classes and Interfaces
|
Week 03
|
28
|
3.28. Relationships – Basic Concepts Object Oriented Programming Defined
|
|
29
|
3.29. Relationships – Basic Concepts Association
|
|
30
|
3.30. Relationships – Basic Concepts Aggregation and Composition
|
|
31
|
3.31. Object Lifetime and Visibility Inheritance
|
|
32
|
3.32. Object Lifetime and Visibility Composition
|
|
33
|
3.33. Object Lifetime and Visibility Association
|
|
34
|
3.34. Object to Relational Mapping Basics
|
|
35
|
3.35. Object to Relational Mapping Mapping Inheritance
|
|
36
|
3.36. Mapping Inheritance - Vertical Mapping
|
|
37
|
3.37. Mapping Composition
|
|
38
|
3.38. Mapping Association
|
|
39
|
3.39. Mapping Cardinality of Association
|
|
40
|
3.40. Object to Relational Mapping - Summary
|
Week 04
|
41
|
4.41. Object Oriented Programming – Inheritance and Polymorphism
|
|
42
|
4.42. Object Oriented Programming – Object Creation and Factory Method
|
|
43
|
4.43. Object Oriented Programming- The Magic Behind Polymorphism
|
|
44
|
4.44. Object Oriented Programming- Implementing Composition
|
|
45
|
4.45. Object Oriented Programming- Inheritance vs Composition
|
|
46
|
4.46. Implementing Uni-directional Associations
|
|
47
|
4.47. Implementing Bi-directional Associations
|
|
48
|
4.48. SOLID Design Principles-Introduction
|
|
49
|
4.49. SOLID Design Principles Single Responsibility Principle (SRP)
|
|
50
|
4.50. Single Responsibility Principle (SRP) - Example
|
|
51
|
4.51. SOLID Design Principles Open-Closed Principle (OCP)
|
Week 05
|
52
|
5.52. Open-Closed Principle (OCP) - Example
|
|
53
|
5.53. Liskov’s Substitution Principle (LSP)
|
|
54
|
5.54. Liskov’s Substitution Principle (LSP) - Example
|
|
55
|
5.55. The True Meanings of IsA Relationship
|
|
56
|
5.56. SOLID Design Principles Interface Segregation Principle (ISP)
|
|
57
|
5.57. Interface Segregation Principle (ISP) - Example
|
|
58
|
5.58. SOLID Design Principles Dependency Inversion Principle (DIP)
|
|
59
|
5.59. Dependency Inversion Principle (DIP) - Example
|
|
60
|
5.60. Good OO Design Principles Law of Demeter (LoD)
|
|
61
|
5.61. Law of Demeter(LoD) - Example
|
|
62
|
5.62. Action-Oriented Design in the Disguise of Object-Oriented Design
|
|
63
|
5.63. Handling Poorly Distributed System Intelligence
|
|
64
|
5.64. Modelling Policy –Jacobson's Heuristic
|
Week 06
|
65
|
6.65. Handling Roles - Player Role Pattern
|
|
66
|
6.66. Handling multiple discriminators using Player-Role Pattern
|
|
67
|
6.67. Software Design and Architecture-Abstraction-Occurrence Pattern
|
|
68
|
6.68. Software Design and Architecture-Reflexive Associations
|
|
69
|
6.69. Software Design and Architecture-Design Patterns Introduction
|
|
70
|
6.70. Software Design and Architecture-Elements of Design Pattern
|
|
71
|
6.71. Categories of Design Patterns
|
|
72
|
6.72. Benefits and drawbacks of design patterns
|
|
73
|
6.73. Singleton Design Pattern
|
|
74
|
6.74. Strategy Design Pattern
|
|
75
|
6.75. Design Patterns - Introduction - Object-Morphing and Strategy Pattern
|
|
76
|
6.76. Facade Design Pattern
|
Week 07
|
77
|
7.77. Modeling State Machine
|
|
78
|
7.78. State Design Pattern
|
|
79
|
7.79. State Design Pattern - Example
|
|
80
|
7.80. Comparison of Strategy and State Design Pattern
|
|
81
|
7.81. Composite Design Pattern
|
|
82
|
7.82. Observer Design Pattern
|
|
83
|
7.83. Refactoring Introduction
|
|
84
|
7.84. Refactoring – A simple example
|
|
85
|
7.85. Refactoring vs Rewriting and optimization
|
|
86
|
7.86. Making Refactoring Safe
|
|
87
|
7.87. Code Smells - Bad smells in code
|
|
88
|
7.88. Code Smells - Bloaters
|
Week 08
|
89
|
8.89. Code Smells - Object-orientation abusers
|
|
90
|
8.90. Code Smells - Change Preventers
|
|
91
|
8.91. Code Smells- Dispensables
|
|
92
|
8.92. Code Smells – Couplers
|
|
93
|
8.93. Refactoring – The Catalog
|
|
94
|
8.94. Refactoring – Extract Method
|
|
95
|
8.95. Refactoring – Replace Temp with Query
|
|
96
|
8.96. Refactoring – Move Method
|
|
97
|
8.97. Refactoring – Replace Conditional with Polymorphism
|
|
98
|
8.98. Refactoring – Introduce Null Object
|
|
99
|
8.99. Refactoring – Example Part I A Video Store
|
|
100
|
8.100. Refactoring – Example Part II Extract Method
|
|
101
|
8.101. Refactoring – Example Part III Extract Method - Pitfalls
|
|
102
|
8.102. Refactoring – Example Part IV Extract Method – Making it More Readable
|
Week 09
|
103
|
9.103. Refactoring – Example Part V Move Method
|
|
104
|
9.104. Refactoring – Example Part VI
|
|
105
|
9.105. Refactoring – Example Part VII
|
|
106
|
9.106. Refactoring – Example Part VIII-Replace Temp with Query
|
|
107
|
9.107. Refactoring – Example Part IX
|
|
108
|
9.108. Refactoring – Managing Refactoring
|
|
109
|
9.109. Problems with Refactoring
|
|
110
|
9.110. MVC – Challenges of Interactive Application
|
|
111
|
9.111. MVC – Example Part I Requirements
|
|
112
|
9.112. MVC – Example Part II Monolithic Console Implementation
|
|
113
|
9.113. MVC – Example Part III Monolithic Mixed UI Implementation
|
|
114
|
9.114. MVC – Example Part IV Models and Interactors
|
|
115
|
9.115. MVC – Example Part V Using Models and Interactors
|
|
116
|
9.116. MVC – Example Part VI
|
|
117
|
9.117. MVC – Example Part VII
|
|
118
|
9.118. MVC – Example Part VIII
|
Week 10
|
119
|
10.119. What is software architecture?
|
|
120
|
10.120. Categories of structures in Architectural Design
|
|
121
|
10.121. Static Software Structures - Modules
|
|
122
|
10.122. Component-and-Connector and Allocation Structures
|
|
123
|
10.123. Quality Attributes
|
|
124
|
10.124. What should not be included in it?
|
|
125
|
10.125. Difference between Architecture and Representation of the Architecture
|
|
126
|
10.126. Difference between Software, System, and Enterprise Architectures
|
|
127
|
10.127. Architectural Views
|
|
128
|
10.128. 4+1 View Model of Software Architecture
|
|
129
|
10.129. Module Structures
|
|
130
|
10.130. Component and Connector Structures
|
|
131
|
10.131. Allocation Structures
|
|
132
|
10.132. Structures and Quality Attributes
|
|
133
|
10.133. Relating Structures to Each Other
|
Week 11
|
134
|
11.134. Choosing an Appropriate Structure
|
|
135
|
11.135. Architectural Patterns – Overview
|
|
136
|
11.136. What makes a good Architecture?
|
|
137
|
11.137. Process Recommendations
|
|
138
|
11.138. Product Recommendations
|
|
139
|
11.139. Architectural Drivers
|
|
140
|
11.140. The Architecture Meta-Frame
|
|
141
|
11.141. Quality Attributes: Introduction
|
|
142
|
11.142. Architecturally Significant Quality Attributes
|
|
143
|
11.143. Guidelines for Quality Attributes
|
|
144
|
11.144. Quality Attributes – Description
|
|
145
|
11.145. Requirements and Constraints
|
|
146
|
11.146. Application Types
|
|
147
|
11.147. Application Types and Deployment Strategy
|
|
148
|
11.148. Application Types – Description
|
|
149
|
11.149. Architecture Styles
|
Week 12
|
150
|
12.150. Architecture Frame – Part I – Cross-Cutting Concerns
|
|
151
|
12.151. Architecture Frame – Part II – Key Cross-Cutting Concerns
|
|
152
|
12.152. Key Engineering Decisions – Part I – Authentication and Authorization
|
|
153
|
12.153. Key Engineering Decisions – Part II – Caching and State
|
|
154
|
12.154. Key Engineering Decisions – Part III – Communication
|
|
155
|
12.155. Key Engineering Decisions – Part IV – Concurrency and Transaction
|
|
156
|
12.156. Key Engineering Decisions – Part V – Data Access
|
|
157
|
12.157. Key Engineering Decisions – Part VI – User Experience
|
|
158
|
12.158. Software Design and Architecture-Agility and Architecture Design
|
|
159
|
12.159. Software Design and Architecture-Key Architecture Principles
|
|
160
|
12.160. Software Design and Architecture-Incremental and Iterative Approach to Architectural Design
|
|
161
|
12.161. Software Design and Architecture-Baseline and Candidate Architectures
|
|
162
|
12.162. Software Design and Architecture-Architectural Spikes
|
|
163
|
12.163. Software Design and Architecture-Architecturally Significant Use Cases
|
|
164
|
12.164. Software Design and Architecture-Reference Application Architecture
|
|
165
|
12.165. Software Design and Architecture-Software Architecture Patterns - Introduction
|
Week 13
|
166
|
13.166. Software Design and Architecture-Difference between Software Architecture Patterns and Design Patterns
|
|
167
|
13.167. Software Design and Architecture-Types of Architecture Patterns
|
|
168
|
13.168. Software Design and Architecture-Module Patterns Layered Pattern – I: Introduction
|
|
169
|
13.169. Software Design and Architecture-Module Patterns Layered Pattern – II: Open vs Closed Layers
|
|
170
|
13.170. Software Design and Architecture-Module Patterns Layered Pattern – III: Tiers vs Layers
|
|
171
|
13.171. Software Design and Architecture-Module Patterns Layered Pattern – IV: Advantages of layered architectures
|
|
172
|
13.172. Software Design and Architecture-Module Patterns Layered Pattern – V: Disadvantages of layered architectures
|
|
173
|
13.173. Software Design and Architecture-Module Patterns Layered Pattern – VI: Client-server architecture (two-tier architecture)
|
|
174
|
13.174. Software Design and Architecture-Module Patterns Layered Pattern – VII: n-tier architecture
|
|
175
|
13.175. Software Design and Architecture-Module Patterns Variations in Layered Pattern
|
|
176
|
13.176. Component-and-Connector Patterns Broker Pattern – I: Introduction
|
|
177
|
13.177. Component-and-Connector Patterns Broker Pattern – II: Advantages and Disadvantages
|
|
178
|
13.178. Component-and-Connector Patterns MVC Pattern
|
|
179
|
13.179. Component-and-Connector Patterns Pipe-and-Filter Pattern
|
|
180
|
13.180. Component-and-Connector Patterns Pipe-and-Filter Pattern – Strengths and Weaknesses
|
Week 14
|
181
|
14.181. Component-and-Connector Patterns Client-Server Pattern
|
|
182
|
14.182. Component-and-Connector Patterns Shared-Data Pattern
|
|
183
|
14.183. Component-and-Connector Patterns Shared-Data Pattern – Strengths and Weaknesses
|
|
184
|
14.184. Allocation Patterns - Multi-tier Pattern
|
|
185
|
14.185. Monolithic Architecture
|
|
186
|
14.186. Monolithic Architecture – Strengths and Weaknesses
|
|
187
|
14.187. Web Application Architecture Overview
|
|
188
|
14.188. Web Application Design Considerations Part I - Maintainability
|
|
189
|
14.189. Web Application Design Considerations Part II - Performance
|
|
190
|
14.190. Web Application Design Considerations Part III - Security
|
|
191
|
14.191. Web Application Frame - Introduction
|
|
192
|
14.192. Web Application Frame - Authentication
|
|
193
|
14.193. Web Application Frame - Authorization
|
|
194
|
14.194. Web Application Frame - Caching
|
|
195
|
14.195. Web Application Frame - Exception Management
|
|
196
|
14.196. Web Application Frame - Logging and Instrumentation
|
|
197
|
14.197. Web Application Frame - Navigation
|
|
198
|
14.198. Web Application Frame - Page Layout
|
Week 15
|
199
|
15.199. Web Application Frame - Page Rendering
|
|
200
|
15.200. Web Application Frame - Presentation Entity
|
|
201
|
15.201. Web Application Frame - Request Processing
|
|
202
|
15.202. Web Application Frame - Session Management
|
|
203
|
15.203. Web Application Frame - Validation
|
|
204
|
15.204. Web Application Frame - Presentation Layer Considerations
|
|
205
|
15.205. Web Application Frame - Business Layer Considerations
|
|
206
|
15.206. Web Application Frame - Data Layer Considerations
|
|
207
|
15.207. Web Application Frame - Service Layer Considerations
|
|
208
|
15.208. Web Application Frame - Testing and Testability Considerations
|
|
209
|
15.209. Web Application Frame - Performance Considerations
|
|
210
|
15.210. Web Application Frame - Security Considerations
|
|
211
|
15.211. Web Application Frame - Deployment Considerations
|
|
212
|
15.212. Web Application Frame Load Balancing
|
|
213
|
15.213. Cloud Computing – Introduction
|
|
214
|
15.214. Cloud Computing – Basic Definitions
|
|
215
|
15.215. Cloud Computing – Service Models and Deployment Options
|
|
216
|
15.216. Cloud Computing – Multitenancy
|
|
217
|
15.217. Cloud Computing – Architecting in Cloud Environment
|
Week 16
|
218
|
16.218. Service-Oriented Architecture – Introduction
|
|
219
|
16.219. What Makes Service-Oriented Architecture Different from other Distributed Solutions?
|
|
220
|
16.220. Benefits of Service-Oriented Architecture
|
|
221
|
16.221. Challenges with Service-Oriented Architecture
|
|
222
|
16.222. Microservice Architecture - Introduction
|
|
223
|
16.223. Characteristics of microservice architecture
|
|
224
|
16.224. Designing Polyglot Services
|
|
225
|
16.225. Stateless versus Stateful Microservices
|
|
226
|
16.226. Microservice Architecture Challenges
|
|
227
|
16.227. Summing it up - What every software architect should know
|
|
|
|