It is an acronym, introduced by Michael Feathers, that introduces five object oriented design principles intended to make software design more understandable, flexible and maintainable.
Single Responsibility Principle
Every module should have only one responsibility and reason to change.
In simpler words, your objects should do only one thing.
The register function doesn't act on a User property but registers the User. This object stores data and has a behaviour.
Every module should be open for extension but closed for modification.
In other words, you should be able to add behaviour to your objects without modifying them.
Every time we add a different Shape we need to modify the function which is going to grow bigger and bigger.
Now adding different shapes does not imply modifying code, but extending it.
Liskov Substitution Principle
Modules should be replaceable with instances of their subtypes.
In other words, a subclass should override the parent class' methods in a way that does not break functionality from a client's point of view.
You can now use both Ostrich and Robin as a Bird, only Robin can fly.
Interface Segregation Principle
Many client-specific interfaces are better than one general-purpose interface.
In other words, make your interfaces small. An object should not be forced to implement a method they don't use just because it is in the interface.
Dependency Inversion Principle
A module should depend upon abstractions, not on concrete implementations.
In other words, by using abstractions between your dependencies you achieve decoupling.
To add ProductOwner I need to add another variable with a different type.
To add ProductOwner no changes are necessary and I created and abstraction to decouple Company and Developer.
By applying these principles you are a step closer to achieving quality code.
There are plenty of good and detailed articles out there, I tried to keep this one short and simple. Hope this was helpful.