Mastering Iterative Object-oriented Development in C#
4.8 (71 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
316 students enrolled

Mastering Iterative Object-oriented Development in C#

with practices of Emergent Design
Bestseller
4.8 (71 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
316 students enrolled
Created by Zoran Horvat
Last updated 12/2018
English
English
Current price: $9.99 Original price: $24.99 Discount: 60% off
30-Day Money-Back Guarantee
This course includes
  • 4.5 hours on-demand video
  • 70 downloadable resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to Udemy's top 3,000+ courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • How to create effective object models even in the most complex projects
  • How to write code iteratively, in very small chunks

  • How to produce clean and extensible code

Requirements
  • Intermediate understanding of object-oriented design
  • Working knowledge of C# and .NET will help, but it is not mandatory
Description

Iterative development is one of those agile techniques that so often turn into their opposite: blinded by the very iterations, developers cannot see the upfront design they are implicitly following. Isn’t there anything we can do to improve iterative development?

In this course, you will see how a complex object-oriented design can grow iteratively, in very small steps. In every step, we will be adding one complete feature to the program, while at the same time paying due attention to principles of good object-oriented design. The end result will be a complex application which is still flexible and extensible - exactly the way we always wanted our object-oriented code to be.

In four and a half hours of this course, you will learn how to control design of classes, design of complex algorithms, and how to recognize and implement data structures.

After completing this course, you will know how to develop a large and complex domain model, which you will be able to maintain and extend further. And, not to forget, the model you develop in this way will be correct and free of bugs.

Who this course is for:
  • Intermediate or senior programmers who would like to improve their skills in object-oriented design
  • Programmers interested in iterative development style
Course content
Expand all 60 lectures 04:38:52
+ Introducing Iterative Development
9 lectures 38:27
Introducing the Development Environment
01:52
The First Glimpse of Iterative Development
04:42
Adding the First Feature
04:31
Preparing for the Complex Algorithm Implementation
04:16
Handling Simple Cases First
04:47
Designing the Algorithm
04:22
Implementing the Algorithm Iteratively
07:29
Summary
01:50
+ Understanding Limitations of Iterative Development
7 lectures 34:10
The Cost of Adding More Features
04:35
Understanding Causes of Code Duplication
04:49
The Cost of Fixing a Design Flaw
06:08
The Cost of Having No Abstractions
06:43
The Cost of Improving Performance
05:43
Wrong Abstractions are the Road to Disaster
03:46
Summary
02:26
+ First Encounter with Emergent Design
7 lectures 33:01
Letting a Class Emerge
05:20
Implementing the First Abstract Concept
06:00
What Have We Got This Far?
02:54
Pushing the Implementation Deeper
05:35
Recognizing the Misplaced Implementation Code
05:41
Even More General-Purpose Code May Appear
05:46
Summary
01:45
+ Structuring Emergent Classes
7 lectures 35:12
Separating General-Purpose Code from the Domain
05:45
Code Separation Leads to Better Performance
05:40
Efficiency Considerations in Operation Pipelines
05:43
Constructing an Efficient Pipeline
06:26
Modifying a Pipeline Stage
03:51
Inserting a New Pipeline Stage
05:38
Summary
02:09
+ Letting the Algorithms Emerge
8 lectures 32:35
Choosing Names for Operations
02:33
Completing an Algorithm Placeholder
03:03
Isolating the Outer Layer of the Algorithm
06:49
Reusing Behavior with a Wrapper
04:59
Parameterizing Algorithms Before Reuse
04:17
Summary
01:25
+ Iterative Development of an Algorithm
7 lectures 35:19
Defining the Role of a Function
05:24
Letting the Function Emerge
05:01
Letting an Abstraction Emerge
05:00
Ordering Use Cases by Complexity
06:51
Implementing the Next Simplest Use Case
05:45
Cleaning Up After Every Iteration
05:30
Summary
01:48
+ Letting the Data Structures Emerge
7 lectures 31:43
Reiterating the Requirements
02:09
Adding an Isolated Design Element
04:17
Generalizing the Function
05:25
Attaching Unrelated Behaviors to a Class
06:06
Recognizing the Missing Data Structure
05:31
Reaping the Benefits of a Custom Data Structure
06:11
Summary
02:04
+ Wrapping It All Together
8 lectures 38:25
Augmenting the Algorithm
05:36
Completing the Data Structures and Types
05:30
Developing a General-Purpose Algorithm
03:35
Completing the Algorithm Dependencies
04:20
Adding Even More Complex Features
03:55
Adding the Most Complex Feature
05:17
Demonstrating the Power of the Domain Model
05:32
Summary
04:40