Understanding Object-Oriented Programming (OOP): A guide for bootcamp graduates
Tags: bootcamp, career, beginners, abotwrotethis
Published: 2023-03-24 08:47:24

Bootcamps can be a great way to kickstart your programming career, but they may not always provide a comprehensive understanding of Object-Oriented Programming (OOP) concepts in Java. As a bootcamp graduate myself, I know firsthand how important it is to supplement your education with additional learning resources to succeed as a software developer.

My background is in digital marketing, where I spent more than 15 years working as a liaison between clients and tech teams. While I enjoyed implementing tracking pixels and solving problems with tag management, I decided that I wanted to take my skills to the next level and learn how to create programs myself. At the age of 35, I enrolled in an offline bootcamp that was supposed to cover the basics to intermediate levels of programming in Java.

However, I soon realized that the knowledge I gained from the bootcamp was only suitable for beginners. The same amount of knowledge could be obtained from online courses on Udemy and other platforms. When I landed my first job as a developer - not in Java, but in PHP - I realized that what was really important for success in the field was an understanding of OOP principles and the ability to work effectively in a team.

So, what are the principles of OOP? In OOP, everything is represented as an object, which has properties and methods. The four main principles of OOP are:

1. Encapsulation: This principle is about grouping related data and functions together into a single unit called a class. Encapsulation helps to hide the implementation details of a class from other classes, which makes it easier to modify the code in the future without affecting the other parts of the program.

2. Inheritance: This principle allows you to create a new class by inheriting the properties and methods of an existing class. Inheritance is useful for creating new classes that are similar to existing ones, but with some additional or modified functionality.
 
3. Polymorphism: This principle refers to the ability of objects to take on multiple forms. Polymorphism allows you to use a single interface to represent multiple types of objects.
 
4. Abstraction: This principle is about focusing on the essential features of an object and ignoring the non-essential ones. Abstraction allows you to create simpler and more manageable code by hiding the complexity of the underlying implementation.

There are also some essential sets of rules that you should know before you even try to apply for a position. They have elegant abbreviations that help you memorize them: KISS, DRY and SOLID. 

SOLID: SOLID is an acronym that stands for Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. These five principles are considered fundamental to building robust, maintainable software.

- Single Responsibility Principle: This principle states that a class should have only one reason to change. Each class should do one thing, and do it well.

- Open-Closed Principle: This principle states that classes should be open for extension, but closed for modification. In other words, you should be able to add new functionality without having to change existing code.

- Liskov Substitution Principle: This principle states that subclasses should be substitutable for their base classes. In other words, you should be able to use a subclass wherever you can use its parent class.

- Interface Segregation Principle: This principle states that clients should not be forced to depend on interfaces they do not use. Interfaces should be tailored to specific use cases.

- Dependency Inversion Principle: This principle states that high-level modules should not depend on low-level modules. Instead, they should both depend on abstractions.

KISS: KISS stands for "Keep it simple, stupid." This principle states that software should be designed as simply as possible, without unnecessary complexity. Simple code is easier to read, test, and maintain.

DRY: stands for Don't Repeat Yourself. I won't repeat myself, it's self-explanatory. This applies to both one class/module that you create as for the whole application. Especially when you work with frameworks. 

Frameworks... Frameworks are also something that the cheap bootcamps mostly ommit. Basically, the whole bootcamp that you pay the $1-2k for should be an introduction to handling a framework and understanding what part of application would you like to engineer: back-end, front-end, or do you want to go for the whole stuff from the beginning. 

In addition to OOP principles and frameworks, it's also important for developers to know how to work effectively in a team. This includes skills such as documentation, task estimation, and version control. Some of the essential tools for team collaboration include:

- Documentation: Good documentation is essential for ensuring that other team members can understand your code and use it effectively. This includes comments in the code, README files, and technical specifications.

- Task estimation: Being able to estimate the time needed for a task is essential for effective project planning. This involves breaking down tasks into smaller sub-tasks, estimating the time required for each sub-task, and keeping track of progress.

- Version control: Version control tools such as Git allow team members to collaborate on a codebase without overwriting each other's work. Version control also enables developers to revert to earlier versions of the code if necessary.

Finally, it's worth noting that one year of coding on platforms such as Hyperskill by JetBrains is a great way to gain a deeper understanding of your chosen language and prepare for your first job as a developer. While bootcamps can provide a good starting point, it's important to continue learning and practicing on your own to build your skills and become a successful software developer.