Using SOLID Principles to Write Better Code - A Crash Course
4.2 (907 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.
3,315 students enrolled

Using SOLID Principles to Write Better Code - A Crash Course

Software Architecture: A rapid, hard-hitting introduction to designing great object-oriented code in Java, C# and more.
4.2 (907 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.
3,315 students enrolled
Created by Riaan Nel
Last updated 8/2018
English
English
Current price: $58.99 Original price: $84.99 Discount: 31% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 40 mins on-demand video
  • 4 articles
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Apply SOLID principles in order to write better code.
  • Use SOLID principles to evaluate existing code.
  • Understand the long-term benefits of writing good code.
  • Understand the characteristics that help differentiate good code from bad code.
  • Understand software architecture principles that can help you produce well-structured code.
Course content
Expand all 11 lectures 52:06
+ Introduction
1 lecture 06:22

In this lecture, we'll briefly discuss what this course is about, what SOLID principles are, and how you can benefit from applying them.

Preview 06:22
+ SOLID Principles
6 lectures 39:45

In this lecture, we'll discuss the Single Responsibility Principle (SRP).

Preview 07:00

In this lecture, we'll discuss the Open/Closed Principle (OCP).

Open/Closed Principle
06:54

In this lecture, we'll discuss the Liskov Substition Principle (LSP).

Liskov Substitution Principle
06:38

In this lecture, we'll discuss the Interface Segregation Principle (ISP).

Interface Segregation Principle
05:22

In this lecture, we'll discuss the Dependency Inversion Principle (DIP).

Dependency Inversion Principle
05:34

In this lecture, you can review the five SOLID principles at your own pace.

Review: SOLID Principles
08:17

A review of the SOLID principles and concepts that we've covered in this section.

Quiz: SOLID Principles
7 questions

In this quiz, we'll look at how we can refactor code that violates SOLID Principles.

Quiz - Refactoring
10 questions
+ Summary
4 lectures 05:59
Summary
02:34

In this lecture, we'll have a look at the application of SOLID principles in a real-world project.

SOLID Principles in Practice
01:16

This page contains a list of quotes and references used throughout the course.

Quote/Reference List
01:11

This lecture contains a discounted coupon for my course on Fluent API Design.

Bonus Lecture: Discount Coupon
00:57
Requirements
  • You should have experience with an object-oriented programming language, such as Java or C#.
  • You should have an understanding of object-oriented programming principles, such as inheritance.
Description

Write Better Code

It's easy enough to write code that works - however, code that simply 'works' just isn't good enough.  Is it easy to understand?  Is it easy to maintain?  Is it easy to change?  Is it easy to test?  In other words - does it employ good software architecture principles?

This course is about helping you to learn how to write good code using tried-and-tested principles from the world of object-oriented software development in languages like Java and C#.  Specifically, we'll unpack what SOLID means, what its benefits are, and how you can apply SOLID principles in order to improve the architecture of your own code - regardless of which object-oriented programming language you use.  You'll learn how to look at code, identify problems, and how to improve the code by using SOLID principles.  To help you with this, the course also contains a quiz that is focused on refactoring code to conform to SOLID principles.

It's a short course that you can work through in an hour, but it's intended to equip you with skills that you can apply throughout a lifetime of programming!

Some Review Feedback

"The content is structured, step by step is laid out clearly and concisely, the code examples are definitely the icing on the cake as it takes the principles into real world examples which are very valuable."

"Great course with easy to understand examples. Good for first time explanation and as a refresher"

"Firstly, the course focuses on a really important topic that most developers usually skip over, and secondly the course itself is really well thought through with the examples explaining exactly how code can be improved for readability, testing, and to ensure the code is easy to change later on."

"The salient points were well covered, and the code examples are clear enough to illustrate and support each SOLID principle discussed. As a student, we’re able to understand and appreciate the benefit of applying SOLID principles, and writing better code."

This course includes the option of a 30-day, no-questions-asked refund if you're not happy with it.

Who this course is for:
  • Object-oriented programmers who want to learn how to write better code.
  • Junior- to intermediate Java and C# developers.
  • Anyone with an interest in software architecture and the structure of good code.