🗞 Stream Recap: Object-oriented Encapsulation
Our Tech Journey #4—Here's what you missed
Thank you to the 31 live attendees. Over 500 people have now watched my presentation a week later.
Talking Points
“Encapsulation has a fractal nature. Bleed too much detail in one key area and it will spread its coupling all over your architecture.“
“We are always solving the same problem even when we are in the same industry, but we still have different concepts for what encapsulation is or what it should encompass.”
“Can encompass has-a vs. is-a differences in composition/inheritance models.“
“Encapsulation helps you think of concepts as a small computer. Focusing on how what you use it for, rather than what it needs to run. This usage vs. construction paradigm is the core topic.”
“In biology, the abstraction of a small computer is a Cell. Just like cells, objects communicating with their ‘surrounding’ through their ‘membrane‘ without knowing where the signals are going or coming from—ie. no coupling.“
“Cells that are well-encapsulated come with useful guarantees of behavior and functionality. They do not maintain their guarantees when their membranes rupture or get bypassed. That’s what viruses are.“
Recordings
Highlights (AI generated)
Encapsulation in object-oriented programming is crucial for efficient architecture, organization, and flexibility, and it involves separating responsibilities, hiding implementation details, and creating pure functions to reduce complexity and cognitive load.
00:00 Encapsulation in object-oriented programming is crucial for efficient architecture, but often misunderstood, leading to code issues and organizational challenges.
Today's stream covers encapsulation in object-oriented languages, with a practical demonstration of code editing on screen.
Encapsulation in object-oriented programming helps to leverage themes and architecture systems more efficiently, with a fractal nature that applies from code level to organizational structures.
Encapsulation is often misunderstood, leading to the creation of anemic models and excessive use of mocks in code.
Encapsulation issues in code can lead to delegation problems, domain overlaps, downstream effects, slower deployment times, and breaching of encapsulation through code sharing and getter/setter problems.
Encapsulation in object-oriented programming is important for separating utility from configuration and hiding database solutions, and it's recognized through "is a" and "has a" relationships.
LinkedIn user Thomas is recognized for his writing style, while yesam's comments may be missed due to high privacy settings.
14:59 Encapsulation in object-oriented programming separates responsibilities, hides implementation, and allows for independent system functionality, with discussions on anemic models, inheritance versus composition, and interface design.
Encapsulation is used to separate responsibilities and create a system that is complex but simple to understand, with discussions on anemic models, hiding implementation, and composition versus inheritance.
The importance of developer experience and tooling in building and organizing in-house tooling for larger organizations, including concepts such as implementation versus behavior, inheritance versus composition, interfaces, modules, anemic models, and infrastructure reuse.
Encapsulation in object-oriented programming is about thinking of the encapsulated thing as a small computer, allowing messages to be sent and received without exposing internal data.
Encapsulation is important in interface design to prevent communication between cells and maintain guarantees, especially for stateful objects like entities from a database.
Encapsulation in object-oriented programming hides important data and inner implementation from end users and other developers, allowing for more independence and focus on system functionality.
Object-oriented programming allows for sending messages to objects without being coupled to the mechanism of how the messages are sent, solving the problem of having to deal with multiple parameters in functions.
35:47 Encapsulation in object-oriented programming involves creating pure functions and separating data from behavior to reduce complexity and cognitive load, but breaching encapsulation can lead to issues with temporal coupling.
Denis is building confidence to create a course on software engineering fundamentals and will be using the game Bit Burner as an example due to its messy legacy system.
Encapsulation in object-oriented programming involves creating pure functions that do not rely on external states and encapsulating external dependencies within a class to facilitate testing.
Encapsulation separates data from behavior, but breaching encapsulation by exposing properties from behavior can lead to temporal coupling and spread complexity in code.
Encapsulation in object-oriented programming helps to reduce cognitive load and responsibility by hiding the inner workings of code, but using getters and setters can lead to issues with temporal coupling, which can be resolved by extracting classes and returning instances of the class.
Refactoring code to adhere to the Builder pattern and law of demeter by moving the run method to the class receiving an instance of job, and understanding that method chaining does not violate law of demeter as long as it returns the instance.
It explains the important distinction between static and nonstatic methods and how to make a method chainable.
54:59 Encapsulation in object-oriented programming is crucial for organization and flexibility, allowing for proper definition of functions and avoiding the limitations of inheritance.
The function in object-oriented encapsulation can only know about certain types, allowing for familiarity and the ability to invoke methods regardless of the instance.
Denis discusses the importance of encapsulation in object-oriented programming and how it can lead to better organization and functionality within a system.
Encapsulation allows for flexibility in changing the form of address without breaking the structure, and data types are only important in the context of creation.
Initial inexperience led to the use of an anemic DTO with a getter, hindering the formalization of behavior and causing the need to pass around the wrong thing.
01:08:36 Encapsulation in object-oriented programming hides implementation details, allowing for better control over behavior and design, and the reorganization of objects into use cases.
Encapsulation in object-oriented programming allows for the hiding of implementation details, such as the structure of the form of address, from other classes, resulting in a more flexible and maintainable design.
Refactoring code to encapsulate behavior through an intermediary class allows for better control over the form of address and behavior without relying on excessive public Getters and Setters.
Treat implementation details as hidden and separate objects to achieve a better design and easier testing.
Encapsulating smaller elements of behavior, not data, by splitting classes into smaller units and hiding data behind usage scenarios.
Usage scenarios can be encapsulated into classes to create a high level of granularity and to show how objects are codependent and cannot exist individually.
Reorganize objects into use cases and avoide excessive mocking in object-oriented encapsulation.
01:21:49 Abstracting domain information in a service-oriented architecture is crucial for flexibility, while contract testing and snapshot tests help ensure compatibility with external APIs.
In a service-oriented architecture, it is important to abstract domain information using interactors and driven parts to allow for flexibility in representing the domain across different use cases.
Coupling infrastructure with object-oriented design and the potential conflicts between microservices and object-oriented principles.
Players and software engineers often write tightly coupled code with a "god object" in the game Bit Burner, leading to breaking changes whenever there is an API update.
Testing against contracts and using snapshot tests can ensure that mocks are still correct with the latest updates from external APIs.
Contract testing allows for monitoring and updating API versions to ensure compatibility, and there are various tools available for this, including snapshot testing and acceptance testing.
Large vendors have strict API versions and announce breaking changes, so technologists need to understand and respond to these changes.
01:33:37 Object-oriented programming emphasizes "tell don't ask," flexible software architecture, and unique data storage, but encapsulation challenges arise in languages like TypeScript and C, impacting team coordination and role-switching.
Denis discusses the concept of "tell don't ask" in object-oriented programming and the importance of flexibility in software architecture.
Entities for the database should have private properties and no Getters and Setters, and there can be multiple representations of classes for the same database table.
Different types of data in a system should be stored and accessed in a way that reflects their unique characteristics, rather than using a one-size-fits-all approach, and object-oriented programming involves defining messaging procedures without knowing the specific destination of the message.
Encapsulation in certain languages like TypeScript and C can be challenging because functions may need to be converted from synchronous to asynchronous, causing issues with encapsulation.
Encapsulation affects teams by requiring coordination and can result in the need to constantly switch roles and make changes in multiple places.
Teams may face cascading effects and wear multiple hats if they do not encapsulate their behavioral concerns and focus on the data their services own.
01:44:59 Encapsulation in object-oriented programming separates behavior from data, organizes teams, and improves code quality and communication.
Encapsulation in object-oriented programming allows for the behavior to be defined separately from the data implementation, providing locality to methods and reducing complexity.
Encapsulation of concerns helps organize teams and communication flow better, preventing unnecessary details from being broadcasted and ensuring data flows are articulated and separated properly.
Discussing the importance of encapsulation in project architecture and the need to delegate concerns and reorganize teams for better efficiency and quality.
Start with a use case approach, but be mindful of creating overly large units that lack cohesion, and be sure to challenge and split features to avoid coupling and ensure high cohesion.
Encapsulation in object-oriented programming requires constant vigilance to ensure that the code remains small and easily testable, with careful consideration of contextual boundaries and team structure.
Encapsulation in object-oriented programming helps to reduce architectural coupling and improve code organization and communication.
Archive
You can always find the archive of the Thursday shows on the Stream Recap section and the Wednesday episode on the SnackableCTO. We’re still figuring this out.