Maintainable Code with Java Examples

Maintainable Code with Java Examples, available at $49.99, has an average rating of 5, with 49 lectures, based on 2 reviews, and has 1088 subscribers.

You will learn about 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 This course is ideal for individuals who are Senior developers who already understand the importance of writing easy to maintain code or Intermediate developers. They will benefit a lot from learning these concepts or Beginner programmers might have issues with some of the concepts but will benefit from being exposed to them It is particularly useful for Senior developers who already understand the importance of writing easy to maintain code or Intermediate developers. They will benefit a lot from learning these concepts or Beginner programmers might have issues with some of the concepts but will benefit from being exposed to them.

Enroll now: Maintainable Code with Java Examples

Summary

Title: Maintainable Code with Java Examples

Price: $49.99

Average Rating: 5

Number of Lectures: 49

Number of Published Lectures: 49

Number of Curriculum Items: 49

Number of Published Curriculum Objects: 49

Original Price: $109.99

Quality Status: approved

Status: Live

What You Will 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

Who Should Attend

Senior developers who already understand the importance of writing easy to maintain code

Intermediate developers. They will benefit a lot from learning these concepts

Beginner programmers might have issues with some of the concepts but will benefit from being exposed to them

Target Audiences

Senior developers who already understand the importance of writing easy to maintain code

Intermediate developers. They will benefit a lot from learning these concepts

Beginner programmers might have issues with some of the concepts but will benefit from being exposed to them

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.

Command and query separation –You can separate your methods in two types: commands and queries. I talk about how to make this separation and what are the benefits.

Tell don’t ask –Tell your objects what to do, don’t ask what their state is.

The law of Demeter –Only use objects that were available when your method started.

Coding good practices –Close to the code practices that help keep your code maintainable.

Code Smells –A code smell indicates that something is wrong in your code. Some of them repeat themselves often and have names.

If and Boolean functions –“If” and “Boolean functions” deserve special attention when talking about maintainable code.

Programming languages particular features are dubious –There is something common in programming languages. Some sort of common programming language. I think this commonality is good and should be used a lot at the expense of particular language features.

SOLID programming –In this lecture I discuss SOLID programming and which principles I think are good and important and which not so much.

Objects Calisthenics –Object calisthenics are a set of strict programming principles created by Jeff Bay, that might help your code be more maintainable.

Optimization, language speed and maintainable code –I explain why language speed is not important for most projects.

Maintainability scarcity –Time is expensive. Here I explain why and a bit how to focus refactoring on the areas of the project where it will bring the most benefit.

Maintainability architecture –I am in favor of writing code, building unit tests and refactoring over upfront architecture.

Encapsulation is a friend –Objects should keep their internals to themselves.

Abstraction (modeling) is a friend –Taking entities from the real world and abstracting them into classes makes it easier for the mind to understand what is going on in code.
Composition is a friend, inheritance is not –Classes should use other classes, not inherit them, to avoid complex entangling.

Polymorphism – it’s complicated –I recommend staying away from polymorphism, due to the complexity it ads, because of it’s magic nature.

Data classes are a thing and they are OK –Data objects are useful just as they are, they don’t need to pretend to be classical oop objects.

Know the pattern types –There are different pattern types and I think that this is important.

Use Simple patterns –It’s good to know and use simple programming patterns.

Stay away from Complex patterns –Complex and hard to understand patterns are not something you want to use.

Maintainability through tests –Tests, especially unit tests, are a core pillar for writing maintainable code.

TDD –Test Driven Development is takes time and patience but is rewarding.

High Level First –I like to write code by first writing method calls to methods that don’t exist yet. This way I lay out the entire high level algorithm just with method names. After that I finish up by writing the body of the methods.

Refactoring –Refactoring is an important pillar in keeping the code maintainable.

Continuous refactoring –Always refactor when going through code.

Refactor for simplicity –A special type of refactoring that I like is to refactor the code to make less complex.

Big refactoring –Care must be taken when doing big refactoring.

Complementary concepts –Concepts that are not necessary closely related to writing code.

Yagni –You ain’t gonna need it.

Focus on the present (FOt6P) –Focus on the present is a good mindset when deciding what functionality to implement.

Dry –Don’t repeat yourself to avoid WET – wasting everyone’s time.

Kiss –Keep it simple stupid.

The 80/20 rule –80% of effects come from 20% of causes.

Worse is better –A worse, simpler, product might be more useful than a more complex one.

Course Curriculum

Chapter 1: Introduction

Lecture 1: Course structure

Lecture 2: Maintainable code pillars and pies

Lecture 3: Maintainable code and me

Lecture 4: Developers and maintainable code

Lecture 5: Maintainable code vs Clean code

Chapter 2: Maintainability Main Concepts

Lecture 1: Small everything

Lecture 2: Indirection

Lecture 3: Extract method and Extract class

Lecture 4: Beautify code

Lecture 5: Naming things to express intent

Lecture 6: Less parameters is better than more parameters

Lecture 7: Single responsibility principle extended

Lecture 8: One to One principle

Lecture 9: Low coupling High cohesion

Lecture 10: Command and Query separation

Lecture 11: Tell dont ask

Lecture 12: The Law of Demeter

Lecture 13: Coding good practices

Lecture 14: Code smells

Lecture 15: If and Boolean functions

Lecture 16: Programming languages particular features

Chapter 3: Maintainability and SOLID, Calisthenics, Performance, Scarcity and Architecture

Lecture 1: SOLID Programming

Lecture 2: Object Calisthenics

Lecture 3: Optimization, language speed and maintainable code

Lecture 4: Maintainability scarcity

Lecture 5: Maintainable architecture

Chapter 4: Maintainability and Inheritance

Lecture 1: Encapsulation is a friend

Lecture 2: Abstraction (Modeling) is a friend

Lecture 3: Composition is a friend, inheritance is not

Lecture 4: Polymorphism – its complicated

Lecture 5: Data classes are a thing and they are OK

Chapter 5: Maintainability and Programming Patterns

Lecture 1: Know the pattern types

Lecture 2: Use Simple patterns

Lecture 3: Stay away from Complex patterns

Chapter 6: Ways of writing maintainable code

Lecture 1: Maintainability through tests

Lecture 2: TDD

Lecture 3: High Level First

Lecture 4: Refactoring

Lecture 5: Continuous refactoring

Lecture 6: Refactor for simplicity

Lecture 7: Big refactoring

Chapter 7: Complementary concepts

Lecture 1: Complementary concepts

Lecture 2: Yagni

Lecture 3: Focus on the present – FOP

Lecture 4: Dry

Lecture 5: Kiss

Lecture 6: The 80/20 rule

Lecture 7: Worse is better

Lecture 8: Bonus lecture

Instructors

Liviu Oprisan
Developer

Rating Distribution

1 stars: 0 votes

2 stars: 0 votes

3 stars: 0 votes

4 stars: 0 votes

5 stars: 2 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!