On the first Wednesday of each month, at 11am PST, I try to organize a webinar. For about an hour we talk about software development, object-oriented programming and project management (for project management topics listen to the Shift-M podcast). Here is a full list of all webinars on YouTube (don’t forget to subscribe to the channel).
2021
Feb 10, 2021
#55: Encapsulation Is Dead, Let’s Use Distance of Coupling Instead
Encapsulation is one of four fundamental principles in object-oriented programming. However, as we practitioners know, it doesn’t really work. Getters and setters don’t really help, but only make the code more complex. It is suggested to use a different approach to enforce decoupling: distance of coupling metric.
Jan 6, 2021
#54: How to Make a DSL with ANTLR4
You can create your own Domain Specific Language (DSL) using ANTLR4 library in Java. Here we discuss how this can be done and create a new DSL in less than an hour.
2020
Dec 2, 2020
#53: Best Practices of Exception Throwing
We discuss what are good and bad habits in exception throwing: how to create them, whether to use checked or unchecked, when to use more detailed and less detailed objects, and so on.
Nov 4, 2020
#52: RAII in Java
Resource Acquisition Is Initialization (RAII) is a design idea introduced in C++ by Bjarne Stroustrup for exception-safe resource management. Thanks to garbage collection Java doesn’t have this feature, but we can implement something similar, using try-with-resources. Let’s see how exactly.
Oct 7, 2020
#51: Fat and Skinny Design
It seems that type/class hierarchies in OOP may be designed in two extreme ways: either with full encapsulation of data in mind; or with just a few interfaces making raw data visible, and letting classes deal with it, parse it, and turn it into smaller data elements. You may be surprised, but I’m suggesting the second option is more elegant.
August 5, 2020
#50: Veil Objects to Replace DTOs
We all know that DTOs (aka value objects) are evil. But what is the alternative when we need some data to be transferred temporarily? I’m suggesting Veil Objects and this webinar demonstrates how they are used.
March 12, 2020
#49: What Is Cohesion in OOP?
There are two important metrics in OOP: cohesion and coupling. The first one is the most interesting one since it can be measured. There are many ways to measure it. We discuss which of them make sense and why we should care.
2019
December 4, 2019
#48: Why Private Static Literals are Evil?
The most commonly used solution for the code duplication code is private static constants, which sometimes stay in the same class, but very often reside in a special Constants utility class. This approach is very wrong and only kills your design.
November 6, 2019
#47: Aspect Oriented Programming: Pros and Cons
AOP is a very powerful technique, which is so easily can be abused. We discuss how it works, what is it for, and how to use it responsively in order to stay object-oriented.
August 7, 2019
#46: Xembly, an imperative language for XML manipulations
Xembly is an “Assembly for XML”, an imperative language for building and modifying XML documents. I’m using it in many Java projects where I need to build or modify XML pages. Here is a live demonstration of its features.
July 3, 2019
#45: How Much Immutability Is Enough
Immutability is a virtue in object-oriented programming, but very often it is being confused with constants. Those are different things. Immutable objects are not constants and there are a lot of possibilities to make an object immutable but still ready to accept changes.
June 12, 2019
#44: Logging, the Object-Oriented Way
How do you log events from your objects? Do you use static loggers? Do you use static methods? If you do, you are doing it wrong. There is a better, a more object-oriented way to do that.
February 13, 2019
#42: A practical example of making an object-oriented HTTP server in Java
Most web frameworks hide the details of HTTP requests processing from software developers, making it difficult to design a web application right; in the webinar we analyze how it can be done right, in an object-oriented way.
January 2, 2019
#41: How many RETURN statements is enough?
Multiple RETURN statements are considered as bad practice in object-oriented programming. We analyze practical examples and see why exactly those statements are bad or not. The discussion is in this blog post: Why Many Return Statements Are a Bad Idea in OOP.
2018
December 5, 2018
#40: The Power of Decorators
The Decorator design pattern is a powerful tool in object-oriented programming. There is a real practical example demonstrated, from Zold source code.
November 7, 2018
#39: A practical example of ORM-free persistence layer
There is a demonstration of a real web application (mailanes.com), where the persistence layer is designed without the use of any ORM frameworks, on top of plain PostgreSQL Ruby SDK.
October 3, 2018
#38: Parsing Objects vs Parsers
The Parser is a very commonly used pattern in OOP, which is actually not very object-oriented; a better alternative is parsing objects. The discussion is based on this: Don’t Parse, Use Parsing Objects.
September 12, 2018
#37: Names of objects, methods and variables in OOP
Finding the right name for a class, a method, an object, an attribute or a variable is a complex task in OOP. There are a few thoughts and practical examples.
August 8, 2018
#36: What’s wrong with global variables?
We all know that global variables are evil, but most of us keep using them. Here we discuss what exactly is wrong with them. The discussion is based on this blog post: What’s Wrong With Global Variables?
July 4, 2018
#35: When do you validate your objects?
Very often we need to validate our objects for consistency, before working with them. A file may be absent, a database connection may get lost, a data structure may contain invalid information, and so on. When is the right moment to validate that, in a constructor or some time later, in a method? Object Validation: to Defer or Not?
May 10, 2018
#34: How to Get Rid of the NEW Operator
We discussed what was wrong with the operator NEW and how object-oriented code could get rid of it. More details here: Operator new() is Toxic.
April 4, 2018
#33: The Alternative to Fluent Interfaces in Java
We discussed fluent interfaces design pattern by example. We tried to create an HTTP client as an alternative to jcabi-http, without fluent interfaces, but only with decorators and smart objects. This blog post explains the idea: Fluent Interfaces Are Bad for Maintainability.
February 7, 2018
#32: Synchronized Decorators for Thread-Safety
We discussed thread-safety in OOP and synchronized decorators to solve the problem. The discussion was based on this blog post: Synchronized Decorators to Replace Thread-Safe Classes.
January 3, 2018
#31: Decorating Envelopes
We discussed a simple object-oriented technique I keep using in my projects and find very convenient, it was discussed in this blog post: Decorating Envelopes earlier.
2017
December 13, 2017
#30: Lazy Loading via Java Lambda
We went through a number of functional interfaces and classes of Cactoos library and saw how they can be used in order to implement Lazy Loading in an object-oriented way.
November 1, 2017
#29: How to win $4096 in the next year Quality Award?
I’ve shown by examples what quality meant for me when I was deciding which project deserved to be the winner in the annual Quality Award.
October 4, 2017
#28: Object-Oriented Java Web App from Scratch in One Hour: ThreeCopies.com
We discussed a fully functional web app in Java, which was built with the best principles of object-oriented programming in mind. The application was ThreeCopies.com, an online backup solution for server-side data.
August 2, 2017
#27: Releasing Cactoos 0.12
We went through the entire Cactoos library, polished its code and released version 0.12 to Maven Central.
July 12, 2017
#26: Unit Testing vs Debugging
We discussed why debugging was a bad practice in general and how unit testing could replace it in all places. The discussion was based on this article previously published: Are You Still Debugging?.
June 7, 2017
#25: Micro-management vs. micro-tasking
We discussed how bad was micromanagement and how great was micro-tasking. Somehow our discussion was based on this article: Are You a Micromanager?.
May 3, 2017
#24: Inheritance vs. Subtyping
We discussed subtyping in OOP and implementation inheritance, and compared how they are different and which one is good, which one is evil. The discussion was based on this article Inheritance Is a Procedural Technique for Code Reuse.
April 6, 2017
#23: Puzzle Driven Development
We discussed Puzzle Driven Development, the methodology that we’ve been using in our projects since 2009, with a lot of success. More about it here: Puzzle Driven Development.
March 15, 2017
#22: Naked Data isn’t OOP
We will discuss the problem of data presence in object-oriented code and how their negative effect can be neutralized. The discussion will be based on this blog post: Encapsulation Covers Up Naked Data
February 8, 2017
#21: How to Deal With Conflicts in a Software Team
We discussed what was the most effective attitude towards conflicts in a software team, which was aiming for higher quality. The discussion was based on this blog post: How Much Do You Love Conflict?
January 11, 2017
#20: Gradients of Immutability
We discussed what immutability really was, with a few example in Java and EO (new language we’re developing now). The discussion was based on this blog post: Gradients of Immutability.
2016
December 7, 2016
#19: Who Is a Project Manager?
We discussed what was the role of a project manager in a software project and how it was different from other roles. The discussion was based on this article: Who Is a Project Manager?.
September 7, 2016
#18: Printers Instead of Getters in OOP
Getters are evil in OOP, but what is the alternative? Printers is the way to go. The discussion was based on this article: Printers Instead of Getters.
August 3, 2016
#17: The Philosophy of Bugs
We discussed what bugs were for, how they must be understood by the management, how many of them we should expect to find and what is in general the right philosophy of bug tracking. This article were mentioned: When Do You Stop Testing?.
July 7, 2016
#16: Smart Classes and Functionality-Poor Interfaces
We discussed why java.io.InputStream design was wrong, what Smart-Classes are for and why interfaces must be functionality poor. The discussion was based on this blog post: Why InputStream Design Is Wrong
June 1, 2016
#15: How to Cut Corners and Stay Cool
we’ll discuss how to cut corners and stay cool and how to turn chaos into discipline. The discussion will be based on these articles: How to Cut Corners and Stay Cool and It’s Not a School!.
May 4, 2016
#14: Java Annotations Are a Big Mistake
We discussed why Java annotations were actually a mistake in object-oriented programming and how they motivated us to break object’s consistency and turn it into a data bag. The discussion was based on this article: Java Annotations Are a Big Mistake.
April 13, 2016
#13: Who is Software Architect?
Software architect is responsible for failures and is powerful enough to make and overrule any decision. But that is not it. We also talked about delegation of responsibility and micromanagement. Mostly, this webinar summarized what these articles are talking about: Are You a Micromanager? and Who Is Software Architect?.
March 2, 2016
#12: Takes, Java Web Framework, Intro
This was be a very practical Java coding webinar. We created jare.io, a web system, using Takes Framework, immutable objects and the best practices of pure fanatical object-oriented programming. We used this blog post as a guidance: Java Web App Architecture In Takes Framework
February 3, 2016
#11: Daily Stand-Up Meetings Are Evil
We talked about famous daily meetings and why they were actually a bad idea in a properly managed and disciplined software project. The discussion was based on this post: Daily Stand-Up Meetings Are a Good Tool for a Bad Manager
January 6, 2016
#10: Why ORM is an Anti-Pattern?
We discussed why Object-Relational Mapping (ORM) was actually an anti-pattern and its usage must be replaced with SQL-speaking objects. The discussion was based on this blog post: ORM Is an Offensive Anti-Pattern.
2015
December 1, 2015
#9: Dependency Injection Container is a Bad Idea
We discussed why Dependency Injection (DI) containers were not a good idea in object-oriented programming and what they should be replaced with. The discussion was mostly be based on DI Containers are Code Polluters.
November 4, 2015
#8: What Fake Objects Are For?
We discussed the role of fake objects and the importance of their existence in every object-oriented library. The discussion was based on this post: Built-in Fake Objects.
October 7, 2015
#7: A Few Thoughts About Constructors in OOP
We discussed the role of constructors in OOP and a few best practices for their design, including primary vs secondary and code-free design. The discussion was based on these articles: There Can Be Only One Primary Constructor and Constructors Must Be Code-Free.
September 2, 2015
#6: What’s Wrong About Utility Classes?
We discussed a very common design pattern known as “Utility Class” and its negative effects on the quality of design in object-oriented world. The discussion was be based on this post: OOP Alternative to Utility Classes.
August 5, 2015
#5: Don’t Create Objects That End With -ER
We talked about class naming principles and a very typical problem of misusing “-er” suffix for them, for example in Managers, Observers, Controllers, Filters, Helpers, etc. The discussion was based on this post: Don’t Create Objects That End With -ER.
July 1, 2015
#4: Why Getters-and-Setters Is An Anti-Pattern?
We discussed why Getters-and-Setters, a very popular design pattern in object oriented languages, is instead an anti-pattern and must be avoided. The discussion was be based on this blog post: Getters/Setters. Evil. Period.
June 3, 2015
#3: What’s wrong about NULL in OOP?
This webinar was about NULL references/pointers in object-oriented programming and their negative effect on the entire design of your application. The webinar was mostly motivated by this post: Why NULL is Bad?. My attitude towards NULL references is very negative, so be prepared for an OOP “radicalism” there.
May 6, 2015
#2: Immutable Objects vs Common Sense
The second webinar, about immutable objects and their pros and cons in an object-oriented programming. The webinar was based on this post: Immutable Objects Are Not Dumb. I made a few slides for this webinar, to illustrate my point better. There were some interesting questions asked too.
Apr 8, 2015
#1: Objects vs Static Methods
The first webinar, where we discussed the difference between static methods and objects in object-oriented languages, like Java. Of course, I’m in favor of objects :) The webinar is basically motivated by this earlier post: Composable Decorators vs. Imperative Utility Methods. It took a bit longer than an hour.
