UML and Object-Oriented Design Foundations

Here's a brief overview of the main topics we're going to discuss.

Before starting the course, you should be aware of some prerequisites.

Please join our official group to get even more feedback and support!

Managing complex projects wouldn't be possible without systems and rules. In this section, we'll talk about the traditional and the agile approach used for developing software systems.

Dive in to understand how choosing the right development process can streamline your project, whether you're working solo or in a team. This video serves as a primer, establishing a clear contrast between Waterfall's structured phases and Agile's flexible, iterative process.

Let's take a closer look at the Waterfall model, which is being used successfully in life-control, medical and military systems.

Waterfall's rigidity doesn't fit every project. Enter Agile, a dynamic alternative for when flexibility is key.

Has Waterfall become obsolete? Is Agile always the best option? The answer to both questions is "No." 
And here's why.

Although software engineering is a relatively new field, computer programs are present in nearly every aspect of our lives. This lecture is a brief walkthrough of the history of programming. 

While structured programming relies on actions, Object-Oriented programming is organized around objects. So, let's talk about objects.

OOP is all about objects. But, to create an object, we need to have a class first.

Abstraction is one of the fundamental concepts in Object-Oriented programming. This lesson will clarify the "whys" and "hows".

Encapsulation and data hiding are the other pillars of OOP.

Inheritance is a key concept in Object-Oriented Programming. Without inheritance, we’d end up redundant code over and over again.

Polymorphism is the final object-orientation term we discuss. In this lesson, we'll also use a coding example to demonstrate how polymorphism works.

Object-orientation skill tests

How should we start creating an object-oriented system? Is there any recipe for it? In this lecture, I'm going to provide the answer.

The requirements collection or requirements analysis phase paves the road for all the other phases of the object-oriented software design.

Once we gathered the requirements, we can feed them to the next step of the software design process.

Here's why we need a common design language like the Unified Modeling Language.

The Unified Modeling Language is a graphical notation rather than a textual programming language. In this lecture, we'll see how UML helps us in describing the structure and the functionality of a software system.

The use case diagram visualizes the functional requirements of the system. Although it's simple, it's quite powerful. Let's see how it works.

Let's put what you've learned into action by solving a challenge. Your goal is to draw a use case diagram that provides an overview of an elevator system.

In this video, I show you how I would approach this challenge.

In this lecture, we'll delve into class diagrams, the most frequently used UML diagram types. 

Your goal for this challenge is to create the class diagram of an elevator maintenance robot.

Check out my solution for the Elevator Maintenance Robot class diagram.

UML allows us control who can access the attributes and the methods of our classes. This lecture is about visibility.

The next logical step after identifying the key classes in our system is figuring out the relationships between them.
First, we'll talk about associations.

In UML, we use generalization to express that one model element is based on another model element.

In this video, we'll talk about the other UML relationships: dependency, aggregation, composition and realization.

UML provides dynamic diagrams to represent how objects communicate with each other. The most common dynamic diagram is the sequence diagram.

The activity diagram is a useful technique to represent behavioral logic.

Statechart diagrams describe the states of an object while identifying the events responsible for the state changes.

Various quizzes to verify your knowledge about the most frequently used UML diagrams.

I firmly believe that the best way to learn is by doing. In this module, I'll walk you through the process of designing a note-taking application. This exercise will allow you to practice the concepts you've learned so far.

In this lecture, I’m going to illustrate the requirements collection phase through a real example.

Now that we've got the requirements, let's write some user stories.

In this lecture, we’re going to represent our user stories as use case diagrams.

Let’s create the static structure of our system for Epic #1: Note Management. We’ll identify the main classes and their relationships.

We'll finalize our class diagram by identifying the classes involved in the second and third epics, specifically Security and Cloud Syncing.

We'll describe the note creation scenario in the form of a sequence diagram.

Follow along as we create an activity diagram that visualizes the process of creating, saving, and syncing a note to the cloud.

Let's visualize the possible states of a note object through a state diagram.

In this video, we’ll explore two critical issues that can arise while crafting your state diagrams and discuss how to resolve them.

The case study as downloadable PDF.