What you’ll learn:
How to write maintainable code – code that is easy to maintain and extend
Core concepts related to code maintainability like: indirection, extract method, beautify code
How things like SOLID, Objects Calisthenics, Language speed and Architecture affect code maintainability
Which concepts related to Inheritance can help you and which stand in the way of writing easy to maintain code
How programming patterns affect Code Maintainability
In what ways you can write maintainable code, like TDD, High Level First, Continuous refactoring
Complementary concepts to programming that can help keep your code easy to maintain, like YAGNI, DRY, KISS, FOP
Requirements:
You need to already know how to write code in Java
Description:
I talk about a number of concepts in this course that should make your code easier to maintain.You might want to use some of these concepts and you might want to ignore others.
But if you know what is going on, you are not developing in the dark.
In programming, unlike photography, this is not something you should do.The course is split into seven sections.
The first section is the introduction.
In the second section I talk about close to the code concepts, like indirections, small functions and beautify code.
In the third section I talk about larger groups of concepts and how they relate to maintainability.
I present things like SOLID programming, Object Calisthenics and language speed through the code maintainability lenses.
In the fourth section I talk about how Inheritance affects maintainability.
I explain things like why Encapsulation and Modeling will help you and why you should be careful when using inheritance and polymorphism.
In the fifth section I talk about how programming patterns relate to maintainability.
I try bring attention to pattern types and I recommend using the simple ones and staying away from the complex ones.
In the sixth section I talk about ways of writing maintainable code.
I describe and recommend things like Test Driven Development, High Level First and Continuous Refactoring.
In the seventh section I talk about concepts complementary to programming that can help you write maintainable code, like Yagni, Dry, Kiss and Fop.
Here is a more in-depth list of things you will learn about in each lecture:
Small everything – The most important principle of maintainable code is to work with small units of code: small methods and small classes.
Indirection – In this lecture I talk about indirection, a very useful principle that stands at the core of maintainable code together with Small everything. From indirection we can deduce useful principles and refactoring techniques like beautify code and extract method.
Extract method and extract class – Extract method and Extract class are the most important refactoring techniques you need to know.
Beautify Code – Make code easier to read and understand using indirection.
Naming things to express intent – Names are our tool to express almost with free speech what we are doing in our code.
Less parameters is better than more parameters – I talk about how the number of parameters is important and how you can bring that number down.
Single responsibility principle extended – I talk about the most important concept in SOLID programming, SRP and how it can be extended as a concept even to row level.
One to One principle – A lot of good programming principles seem to have one thing in common: they can be represented as one to one relationships.
Low coupling High Cohesion – I talk about how it’s good to keep you classes and methods decoupled but with high cohesion.
