# Object-oriented programming (OOP)

Object-oriented programming (OOP) is a software development paradigm that organizes code around objects combining data and the functions that operate on it.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## A Beginner's Guide to Classes and Objects in C++

DevFeed: [A Beginner's Guide to Classes and Objects in C++](<https://devfeed.tech/articles/a-beginner-s-guide-to-classes-and-objects-in-c-140464.md>)

Original publisher: [Read original article](<https://hackernoon.com/a-beginners-guide-to-classes-and-objects-in-c?source=rss>)

Author: Viktor Tr

Published: 2026-11-18T06:00:02Z

Content type: article

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [class](<https://devfeed.tech/topics/class.md>), [c/c++](<https://devfeed.tech/topics/c-c-plus-plus.md>), [object](<https://devfeed.tech/topics/object.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [2015](<https://devfeed.tech/tags/2015.md>), [2020](<https://devfeed.tech/tags/2020.md>), [3](<https://devfeed.tech/tags/3.md>), [about](<https://devfeed.tech/tags/about.md>), [accessible](<https://devfeed.tech/tags/accessible.md>), [after](<https://devfeed.tech/tags/after.md>), [all](<https://devfeed.tech/tags/all.md>), [allows](<https://devfeed.tech/tags/allows.md>), [beginner](<https://devfeed.tech/tags/beginner.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [c-plus-plus-access-specifiers](<https://devfeed.tech/tags/c-plus-plus-access-specifiers.md>), [c-plus-plus-member-functions](<https://devfeed.tech/tags/c-plus-plus-member-functions.md>), [c-plus-plus-object-lifetime](<https://devfeed.tech/tags/c-plus-plus-object-lifetime.md>), [c-plus-plus-oop](<https://devfeed.tech/tags/c-plus-plus-oop.md>), [c-plus-plus-programming](<https://devfeed.tech/tags/c-plus-plus-programming.md>), [c-plus-plus-programming-basics](<https://devfeed.tech/tags/c-plus-plus-programming-basics.md>), [classes](<https://devfeed.tech/tags/classes.md>), [example](<https://devfeed.tech/tags/example.md>), [functions](<https://devfeed.tech/tags/functions.md>), [guide](<https://devfeed.tech/tags/guide.md>), [object](<https://devfeed.tech/tags/object.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [object-oriented-programming](<https://devfeed.tech/tags/object-oriented-programming.md>), [programming](<https://devfeed.tech/tags/programming.md>), [scope-resolution-operator](<https://devfeed.tech/tags/scope-resolution-operator.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

The article explains C++ classes and objects through a Car example. A class groups member variables and functions; private fields hold the car's brand, model, and year, while public methods provide the interface. A constructor initializes those values, displayCar() prints them, updateYear() changes the year, and the destructor runs when the object's lifetime ends. It recommends declaring the class in a .h or .hpp file and defining its member functions in a .cpp file, using Car:: scope resolution to identify those definitions as belonging to the class. The example traces creating a Car, displaying and updating its state, and automatic destruction when main() ends. Encapsulation is presented as a way to restrict direct access and reduce accidental modification.

### Source excerpt

Learn C++ object-oriented programming with a practical example covering classes, objects, constructors, destructors, encapsulation, and member functions.

## Fluent Interface in C - Look ma, no this!

DevFeed: [Fluent Interface in C - Look ma, no this!](<https://devfeed.tech/articles/fluent-interface-in-c-look-ma-no-this-141042.md>)

Original publisher: [Read original article](<http://opensource.googleblog.com/2026/11/fluent-interface-in-c-look-ma-no-this.html>)

Author: Google Open Source (noreply@blogger.com)

Published: 2026-11-17T19:30:00Z

Content type: article

Language: en

Sources: [Google Open Source Blog](<https://devfeed.tech/sources/google-open-source-blog.md>)

Topics: [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [Collections](<https://devfeed.tech/topics/collections.md>), [object](<https://devfeed.tech/topics/object.md>), [Boilerplate](<https://devfeed.tech/topics/boilerplate.md>)

Tags: [array](<https://devfeed.tech/tags/array.md>), [automatic](<https://devfeed.tech/tags/automatic.md>), [boilerplate](<https://devfeed.tech/tags/boilerplate.md>), [buffer](<https://devfeed.tech/tags/buffer.md>), [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [call](<https://devfeed.tech/tags/call.md>), [chaining](<https://devfeed.tech/tags/chaining.md>), [cleanup](<https://devfeed.tech/tags/cleanup.md>), [collections](<https://devfeed.tech/tags/collections.md>), [collector](<https://devfeed.tech/tags/collector.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [data](<https://devfeed.tech/tags/data.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [developer-tools](<https://devfeed.tech/tags/developer-tools.md>), [expression](<https://devfeed.tech/tags/expression.md>), [fluent](<https://devfeed.tech/tags/fluent.md>), [functions](<https://devfeed.tech/tags/functions.md>), [interface](<https://devfeed.tech/tags/interface.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [programming-languages](<https://devfeed.tech/tags/programming-languages.md>), [this](<https://devfeed.tech/tags/this.md>)

### AI overview

The `iso-c-chaining` demonstration library uses standard C mechanisms to provide fluent chains and automatic cleanup of temporary objects. Each type places a shared `ChGenericEl` structure first, enabling generic operations such as serialization and deletion; per-type `self()` pointers track the active object, while an intrusive stack restores the outer container after nested chains. Reference counts start at zero: consuming methods can free unowned temporaries, containers claim values by incrementing the count, and `ch_release()` frees objects when their last reference is gone. Callers use `$(obj)` to bind existing objects into a chain and `->$$` to retain a result. The excerpt also describes typed arrays backed by contiguous raw buffers to avoid per-element function pointers. Examples include nested maps, SQLite query results serialized by an HTTP server, and vector operations. The library is presented as an ISO C89 demonstration; `_Thread_local` can make the stack thread-specific in C11.

### Source excerpt

by Daniel Miller, AI4SQL Team Can C be Object Oriented? Yes! Object-oriented languages like Python, Java, Rust, or C++ offer native object methods and automatic object lifetime cleanup, enabling chain operations on data structures, so you can call obj->a()->b()->c() and each method knows what it's working on. These fluent interfaces are common to many libraries that streamline configuration and reduce boilerplate. Let's take a look at an example: ChSlice *mid = ch_new_String("One_Two_Three_Four") ->append("_Five_Six") ->split("_") ->sub_slice(1, 4); puts(mid->generic.to_chars()); /* ["Two","Three","Four","Five"] */ ch_release(mid); This chain of functions takes a string, appends it to another string, splits it into an array, and slices the array in one chain of function calls. It's a pretty basic demonstration of using fluent interfaces for building a data structure with method chaining. But if I told you this was plain ANSI-C, you would think I committed a preprocessor felony and leaked three heap allocations along the way. And there are two big reasons why: There are no objects in C. No member variables or methods. No this or self to reference your object's data. The function append("_Five_Six") has no attached state, seeing only a single string literal and whatever is global. There is no garbage collector. In standard C, chaining heap allocations together without saving each intermediate pointer to a variable and freeing it by hand inevitably results in a memory leak. Manipulating strings and collections in C usually means threading state through standalone functions (str_append(s, ...)), holding onto every intermediate pointer, and freeing each temporary buffer by hand. We built iso-c-chaining to explore how far we could push fluent method chaining and automatic temporary cleanup using only standard ISO C. Here is how the library appends to a string, splits it on a delimiter, and takes a sub-slice of the resulting array in a single expression. This code does exa

## Beyond Synthetic Benchmarks: Evaluating LLM Performance on Real-World Class-Level Code Generation

DevFeed: [Beyond Synthetic Benchmarks: Evaluating LLM Performance on Real-World Class-Level Code Generation](<https://devfeed.tech/articles/beyond-synthetic-benchmarks-evaluating-llm-performance-on-real-world-class-level-code-generation-137915.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2510.26130>)

Author: Musfiqur Rahman, SayedHassan Khatoonabadi, Emad Shihab

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [LLM evaluation / benchmarking](<https://devfeed.tech/topics/llm-evaluation-benchmarking.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Retrieval Augmented Generation (RAG)](<https://devfeed.tech/topics/retrieval-augmented-generation-rag.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>)

Tags: [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [class](<https://devfeed.tech/tags/class.md>), [code](<https://devfeed.tech/tags/code.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [llm](<https://devfeed.tech/tags/llm.md>), [performance](<https://devfeed.tech/tags/performance.md>), [real-world](<https://devfeed.tech/tags/real-world.md>), [synthetic](<https://devfeed.tech/tags/synthetic.md>)

### AI overview

RealClassEval's 400 classes from open-source repositories expose a large gap between synthetic and real-world class-level code generation: seven evaluated LLMs achieved 84-89% correctness on synthetic tasks but 25-34% on real-world classes, with little difference between seen and unseen codebases. Richer specifications and repository context did not close the gap. Documentation improved results by 1-3%, while retrieval augmentation improved them by 4-7%, particularly with incomplete specifications. AttributeError, TypeError, and AssertionError accounted for 84% of failures; synthetic failures were more logic-focused, while real-world failures reflected object-oriented challenges. These abstract-level findings suggest implementation remains a key bottleneck, though the supplied text does not provide full evaluation details.

### Source excerpt

arXiv:2510.26130v3 Announce Type: replace Abstract: Large language models (LLMs) have advanced rapidly from well-studied function-level code generation to emerging repository-level approaches, yet this progression reveals a critical gap: class-level code generation, which is the fundamental building block connecting individual functions to complete repositories, remains systematically underexplored. Understanding class-level capabilities is a prerequisite to repository-level success, as current approaches cannot distinguish whether failures stem from basic implementation deficiencies or sophisticated context management issues. We introduce RealClassEval, a benchmark derived from real-world open-source repositories, comprising 400 classes divided into seen and unseen partitions based on model training cutoffs. Our systematic evaluation across seven state-of-the-art LLMs reveals fundamental limitations masked by synthetic benchmarks: while LLMs achieve 84 to 89% correctness on synthetic tasks, they attain only 25 to 34% on real-world classes, with minimal distinction between seen and unseen codebases. Notably, this performance range converges with concurrent work using rich natural language descriptions and repository context, suggesting that specification complexity cannot overcome core implementation bottlenecks. Documentation provides marginal improvements (1 to 3%), while retrieval augmentation yields greater gains (4 to7%), specifically with incomplete specifications. Error analysis reveals AttributeError, TypeError, and AssertionError dominate 84% of failures, with distinct patterns between synthetic (logic-focused) and real-world (object-oriented) scenarios. These findings establish the diagnostic foundation necessary for advancing both fundamental LLM capabilities and sophisticated repository-level approaches, while providing actionable guidance for production deployment strategies.

## Operator and Function Overloading in Custom Python Classes

DevFeed: [Operator and Function Overloading in Custom Python Classes](<https://devfeed.tech/articles/operator-and-function-overloading-in-custom-python-classes-110728.md>)

Original publisher: [Read original article](<https://realpython.com/operator-function-overloading/>)

Author: Malay Agarwal

Published: 2026-11-01T14:00:00Z

Content type: article

Language: en

Sources: [Real Python](<https://devfeed.tech/sources/real-python.md>)

Topics: [Python](<https://devfeed.tech/topics/python.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>)

Tags: [built-in](<https://devfeed.tech/tags/built-in.md>), [classes](<https://devfeed.tech/tags/classes.md>), [function](<https://devfeed.tech/tags/function.md>), [operator](<https://devfeed.tech/tags/operator.md>), [operator-overloading](<https://devfeed.tech/tags/operator-overloading.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

Python routes built-ins and operators through special methods, so defining methods such as `__len__`, `__abs__`, `__str__`, and `__add__` lets custom classes behave naturally with those operations. The examples show an `Order` class exposing cart length and indexing, with `+` returning a new order while `+=` mutates and must return a value. `__len__` must return an integer, and `__str__` must return a string. Reverse methods such as `__radd__` support operands on the left; returning `NotImplemented` lets Python try the other operand's method. A `CustomComplex` example combines representations, arithmetic, comparisons, absolute value, and exponentiation. The text notes that `__repr__` is intended to be a parsable representation, while `__str__` is user-facing.

### Source excerpt

Use Python operator overloading to make built-in functions and operators work with your own classes, and write more Pythonic code.

## Object-Oriented Programming in Python vs Java

DevFeed: [Object-Oriented Programming in Python vs Java](<https://devfeed.tech/articles/object-oriented-programming-in-python-vs-java-110727.md>)

Original publisher: [Read original article](<https://realpython.com/oop-in-python-vs-java/>)

Author: Jon Fincher

Published: 2026-10-31T14:00:00Z

Content type: comparison

Language: en

Sources: [Real Python](<https://devfeed.tech/sources/real-python.md>)

Topics: [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [Java](<https://devfeed.tech/topics/java.md>), [Python](<https://devfeed.tech/topics/python.md>), [class](<https://devfeed.tech/topics/class.md>), [object](<https://devfeed.tech/topics/object.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>), [subclass](<https://devfeed.tech/topics/subclass.md>), [constructor](<https://devfeed.tech/topics/constructor.md>)

Tags: [access-control](<https://devfeed.tech/tags/access-control.md>), [car](<https://devfeed.tech/tags/car.md>), [classes](<https://devfeed.tech/tags/classes.md>), [code](<https://devfeed.tech/tags/code.md>), [color](<https://devfeed.tech/tags/color.md>), [compare](<https://devfeed.tech/tags/compare.md>), [comparison](<https://devfeed.tech/tags/comparison.md>), [compilation-error](<https://devfeed.tech/tags/compilation-error.md>), [complete](<https://devfeed.tech/tags/complete.md>), [composition](<https://devfeed.tech/tags/composition.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [java](<https://devfeed.tech/tags/java.md>), [knowledge](<https://devfeed.tech/tags/knowledge.md>), [learn](<https://devfeed.tech/tags/learn.md>), [object](<https://devfeed.tech/tags/object.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [object-oriented-programming](<https://devfeed.tech/tags/object-oriented-programming.md>), [programming](<https://devfeed.tech/tags/programming.md>), [python](<https://devfeed.tech/tags/python.md>), [vs](<https://devfeed.tech/tags/vs.md>)

### AI overview

The article shows how Java OOP concepts translate into Python and where the languages differ. Java declares typed attributes in class bodies, commonly keeps them private behind getters and setters, and restricts classes to single inheritance while allowing shared behavior through interfaces. Python creates instance attributes with `self` in `__init__`, exposes them by default, and offers properties for controlled access; underscore naming conventions signal non-public attributes but do not provide Java-style access control. Python also supports multiple inheritance and duck typing, while Java uses interface types for polymorphic interchangeability. Both languages provide reflection and type checks, though the article describes Python's `dir()`, `getattr()`, and `callable()` workflow as simpler than Java's reflection APIs. Python dunder methods can customize representations and overload operators; the article notes Java has no comparable operator overloading. Examples use a `Car` class to illustrate these mechanisms and practical pitfalls, including class versus instance attributes.

### Source excerpt

Compare Python vs Java for object-oriented programming and learn how to apply your Java knowledge of classes and objects to Python in a Pythonic way.

## A Modern Smalltalk

DevFeed: [A Modern Smalltalk](<https://devfeed.tech/articles/a-modern-smalltalk-109142.md>)

Original publisher: [Read original article](<https://hackaday.com/2026/10/30/a-modern-smalltalk/>)

Author: Al Williams

Published: 2026-10-30T18:30:54Z

Content type: article

Language: en

Sources: [Hackaday](<https://devfeed.tech/sources/hackaday.md>)

Topics: [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [Squeak/Smalltalk](<https://devfeed.tech/topics/squeak.md>), [object](<https://devfeed.tech/topics/object.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [arduino](<https://devfeed.tech/tags/arduino.md>), [browser](<https://devfeed.tech/tags/browser.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [clone](<https://devfeed.tech/tags/clone.md>), [desktop](<https://devfeed.tech/tags/desktop.md>), [free](<https://devfeed.tech/tags/free.md>), [git](<https://devfeed.tech/tags/git.md>), [gnu](<https://devfeed.tech/tags/gnu.md>), [help](<https://devfeed.tech/tags/help.md>), [install](<https://devfeed.tech/tags/install.md>), [introduced](<https://devfeed.tech/tags/introduced.md>), [mvc](<https://devfeed.tech/tags/mvc.md>), [nice](<https://devfeed.tech/tags/nice.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [open](<https://devfeed.tech/tags/open.md>), [operator](<https://devfeed.tech/tags/operator.md>), [packages](<https://devfeed.tech/tags/packages.md>), [raspberry](<https://devfeed.tech/tags/raspberry.md>), [smalltalk](<https://devfeed.tech/tags/smalltalk.md>), [software-development](<https://devfeed.tech/tags/software-development.md>)

### AI overview

Cuis Smalltalk is a free, portable Smalltalk-80 environment that keeps a simple core and adds complexity through packages. It replaces the traditional MVC framework with Morphic while retaining a style familiar to users of 1990s Smalltalk. The desktop includes workspaces, help documents, and a transcript, and a class browser helps explore classes and their messages. The language treats operations such as addition as messages sent between objects, which can respond differently to the same message. Cuis uses rolling releases, though a stable release may suit application deployment. Packages for Arduino communication over a serial port exist, but they have not been updated lately and may need work.

### Source excerpt

In the history of object-oriented (OO) computer languages, Smalltalk has a special place. It wasn't the first OO language, and it hasn't spread as well as some others. But it ...read more

## Inheritance and Composition: A Python OOP Guide

DevFeed: [Inheritance and Composition: A Python OOP Guide](<https://devfeed.tech/articles/inheritance-and-composition-a-python-oop-guide-109902.md>)

Original publisher: [Read original article](<https://realpython.com/inheritance-composition-python/>)

Author: Isaac Rodriguez

Published: 2026-10-30T14:00:00Z

Content type: article

Language: en

Sources: [Real Python](<https://devfeed.tech/sources/real-python.md>)

Topics: [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [Python](<https://devfeed.tech/topics/python.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>), [class](<https://devfeed.tech/topics/class.md>), [Learning](<https://devfeed.tech/topics/learning.md>), [Tutorial](<https://devfeed.tech/topics/tutorial.md>)

Tags: [abstract-class](<https://devfeed.tech/tags/abstract-class.md>), [cardinality](<https://devfeed.tech/tags/cardinality.md>), [class](<https://devfeed.tech/tags/class.md>), [classes](<https://devfeed.tech/tags/classes.md>), [code-duplication](<https://devfeed.tech/tags/code-duplication.md>), [component](<https://devfeed.tech/tags/component.md>), [components](<https://devfeed.tech/tags/components.md>), [composition](<https://devfeed.tech/tags/composition.md>), [design](<https://devfeed.tech/tags/design.md>), [guide](<https://devfeed.tech/tags/guide.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [object](<https://devfeed.tech/tags/object.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [oop](<https://devfeed.tech/tags/oop.md>), [python](<https://devfeed.tech/tags/python.md>), [relationships](<https://devfeed.tech/tags/relationships.md>)

### AI overview

Inheritance models an "is a" relationship and reuses a base class's interface and implementation; composition models a "has a" relationship, combining objects while keeping their classes more loosely coupled. The excerpt illustrates inheritance with employee types sharing payroll behavior, and shows how expanding roles and pay policies can create large hierarchies. Multiple inheritance can introduce method resolution order and diamond problems that require explicit handling. The composition design instead gives employees separate role and payroll policy objects, so behaviors can be combined or changed without multiplying employee subclasses. The excerpt also covers Python's implicit inheritance from `object`, abstract base classes, and duck typing: a payroll system can accept any object providing the attributes and method it uses. The supplied text ends during the composition example, so its later implementation and conclusions are not available.

### Source excerpt

Learn how inheritance and composition in Python model is-a and has-a relationships, and when to use each to design flexible object-oriented code.

## Episode 73 "Immutable Data Beyond Value Classes" \[AtA\]

DevFeed: [Episode 73 "Immutable Data Beyond Value Classes" \[AtA\]](<https://devfeed.tech/articles/episode-73-immutable-data-beyond-value-classes-ata-106002.md>)

Original publisher: [Read original article](<https://inside.java/2026/10/29/podcast-073/>)

Author: Nicolai Parlog

Published: 2026-10-29T00:00:00Z

Content type: article

Language: en

Sources: [Inside Java](<https://devfeed.tech/sources/inside-java.md>)

Topics: [data](<https://devfeed.tech/topics/data.md>), [JEP-401](<https://devfeed.tech/topics/jep-401.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [Project Valhalla](<https://devfeed.tech/topics/project-valhalla.md>)

Tags: [ata](<https://devfeed.tech/tags/ata.md>), [data](<https://devfeed.tech/tags/data.md>), [features](<https://devfeed.tech/tags/features.md>), [immutable-data](<https://devfeed.tech/tags/immutable-data.md>), [java](<https://devfeed.tech/tags/java.md>), [java-language](<https://devfeed.tech/tags/java-language.md>), [podcast](<https://devfeed.tech/tags/podcast.md>), [project-amber](<https://devfeed.tech/tags/project-amber.md>), [project-valhalla](<https://devfeed.tech/tags/project-valhalla.md>)

### AI overview

The episode examines how Java features help model immutable data with less ceremony. It names flexible constructor bodies, records and value classes, withers, derived record creation, and lazy constants as tools for defining, constructing, copying, and accessing immutable data. The description presents the features as useful individually and in combination; it does not detail their behavior or compare tradeoffs.

### Source excerpt

Recent and upcoming Java features (e.g. value classes, withers, and lazy constants) make it easier to define, construct, copy, and access immutable data

## CVE-2026-115806 - Prime Mover \<= 2.2.1 - Unauthenticated PHP Object Injection via Base64-Encoded Comment during Migration Search-and-Replace

DevFeed: [CVE-2026-115806 - Prime Mover \<= 2.2.1 - Unauthenticated PHP Object Injection via Base64-Encoded Comment during Migration Search-and-Replace](<https://devfeed.tech/articles/cve-2026-115806-prime-mover-2-2-1-unauthenticated-php-object-injection-via-base64-encoded-comment-during-migration-search-and-replace-98659.md>)

Original publisher: [Read original article](<https://cvefeed.io/vuln/detail/CVE-2026-115806>)

Author: CVEFEED.io; wordfence.com

Published: 2026-10-24T05:17:04Z

Content type: news

Language: en

Sources: [Latest High/Critical Vulnerabilitiy Feed](<https://devfeed.tech/sources/latest-high-critical-vulnerabilitiy-feed.md>)

Topics: [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [object](<https://devfeed.tech/topics/object.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [administrator](<https://devfeed.tech/tags/administrator.md>), [allowed](<https://devfeed.tech/tags/allowed.md>), [backup](<https://devfeed.tech/tags/backup.md>), [base64](<https://devfeed.tech/tags/base64.md>), [comment](<https://devfeed.tech/tags/comment.md>), [content](<https://devfeed.tech/tags/content.md>), [cve-2026-115806](<https://devfeed.tech/tags/cve-2026-115806.md>), [export](<https://devfeed.tech/tags/export.md>), [input](<https://devfeed.tech/tags/input.md>), [library](<https://devfeed.tech/tags/library.md>), [migration](<https://devfeed.tech/tags/migration.md>), [object](<https://devfeed.tech/tags/object.md>), [option](<https://devfeed.tech/tags/option.md>), [php](<https://devfeed.tech/tags/php.md>), [plugin](<https://devfeed.tech/tags/plugin.md>), [post](<https://devfeed.tech/tags/post.md>), [programming](<https://devfeed.tech/tags/programming.md>), [property](<https://devfeed.tech/tags/property.md>), [search](<https://devfeed.tech/tags/search.md>)

### AI overview

Prime Mover - Backup and Migration versions through 2.2.1 are described as vulnerable to unauthenticated PHP object injection during migration search-and-replace. An attacker can submit a crafted base64-encoded serialized object as comment content; during a later administrator export or restore, the plugin decodes it and calls unserialize() without an allowed_classes restriction. The description identifies a POP chain in the bundled Freemius library, so it says no additional plugin or theme is needed. The excerpt reports CVSS 9.8 (critical); it does not identify a fixed version.

### Source excerpt

CVE ID :CVE-2026-115806 Published : Oct. 24, 2026, 5:17 a.m. | 1 hour, 43 minutes ago Description :The Prime Mover - Backup and Migration plugin for WordPress is vulnerable to PHP Object Injection in all versions up to, and including, 2.2.1 via deserialization of untrusted input in the migration search-and-replace routine (recursiveUnserializeReplace()). An unauthenticated attacker can store a crafted, base64-encoded serialized object in wp_comments.comment_content through the standard comment-submission endpoint (wp-comments-post.php). When an administrator subsequently performs a routine Prime Mover export or restore, the plugin base64-decodes that stored value and passes it to unserialize() with no allowed_classes restriction. A Property-Oriented Programming (POP) chain is present in the plugin's own bundled Freemius library (FS_Clone_Manager::__set -> FS_Option_Manager::set_option -> store() -> update_option()), so no additional plugin or theme is required -- the plugin ships the gadget itself. Severity: 9.8 | CRITICAL Visit the link for more details, such as CVSS details, affected products, timeline, and more...

## Python Metaclasses

DevFeed: [Python Metaclasses](<https://devfeed.tech/articles/python-metaclasses-97823.md>)

Original publisher: [Read original article](<https://realpython.com/python-metaclasses/>)

Author: John Sturtz

Published: 2026-10-23T14:00:00Z

Content type: article

Language: en

Sources: [Real Python](<https://devfeed.tech/sources/real-python.md>)

Topics: [Python](<https://devfeed.tech/topics/python.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [class](<https://devfeed.tech/topics/class.md>)

Tags: [avoid](<https://devfeed.tech/tags/avoid.md>), [class](<https://devfeed.tech/tags/class.md>), [classes](<https://devfeed.tech/tags/classes.md>), [custom](<https://devfeed.tech/tags/custom.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [oop](<https://devfeed.tech/tags/oop.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

In Python 3, classes are objects whose type is usually `type`; a metaclass is the class that creates classes. Calling `type(name, bases, namespace)` dynamically creates a class, and a custom metaclass derived from `type` can customize that creation--for example, by adding attributes to each class that uses it. This is separate from customizing ordinary instance creation through `__new__()` and `__init__()`. The excerpt compares metaclasses with inheritance and class decorators as ways to give multiple classes shared attributes, and cautions that the simpler approaches are often cleaner. It also notes that Python 2 distinguishes old-style and new-style classes, while all Python 3 classes are new-style. Custom metaclasses are presented as uncommon tools worth understanding, especially when the need for class-creation customization is clear.

### Source excerpt

How Python's metaclasses work as an OOP concept, what they are good for--and why you might want to avoid them in your own programs.

## Object-Oriented Harness: Evolving Agent Harnesses through Object-Oriented Design

DevFeed: [Object-Oriented Harness: Evolving Agent Harnesses through Object-Oriented Design](<https://devfeed.tech/articles/object-oriented-harness-evolving-agent-harnesses-through-object-oriented-design-93724.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.28380>)

Author: Gaotang Li, Bhavana Dalvi Mishra, Yifei Ming, Yanfei Chen, Zhongying CuiZhu, Lesly Miculicich, Long T. Le, Rui Meng, Chun-Liang Li, Hanghang Tong, Chen-Yu Lee, Tomas Pfister

Published: 2026-10-21T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [subclass](<https://devfeed.tech/topics/subclass.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [class](<https://devfeed.tech/topics/class.md>)

Tags: [agent-harnesses](<https://devfeed.tech/tags/agent-harnesses.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [cs-cl](<https://devfeed.tech/tags/cs-cl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [design](<https://devfeed.tech/tags/design.md>), [hierarchy](<https://devfeed.tech/tags/hierarchy.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [performance](<https://devfeed.tech/tags/performance.md>), [router](<https://devfeed.tech/tags/router.md>), [routing](<https://devfeed.tech/tags/routing.md>)

### AI overview

OO-Harness addresses varied task needs by evolving a hierarchy of specialized executable harnesses. During training, an evolution agent uses execution records to create harness subclasses that inherit from a base or existing specialized harness. At test time, a router applies lessons learned during training to select a harness for each task. On three long-horizon benchmarks covering business workflows, workspace tasks, and tool use, it achieved the best performance among the compared methods, with an absolute improvement of up to 15% over the base. The supplied abstract does not specify benchmark details or the ablation findings.

### Source excerpt

arXiv:2610.28380v1 Announce Type: cross Abstract: Agent harnesses are executable code that specifies the prompts, tools, and control flow around a language model. A single global harness can struggle with heterogeneous tasks that require different execution strategies. In this work, we introduce Object-Oriented Harness (OO-Harness), a harness optimization framework that evolves a hierarchy of executable harness classes using object-oriented design. During training, an evolution agent uses execution records to create a family of specialized harnesses, each implemented as a subclass of the base or an existing specialized harness via inheritance. At test time, a harness router uses routing lessons accumulated during training to select a specific harness for each task. Across three long-horizon benchmarks spanning business workflows, workspace tasks, and tool use, OO-Harness achieves the best performance among the compared methods, with an absolute improvement of up to 15% over the base. Extensive ablation studies examine the contributions of its core components.

## The Evolution of Statics: Say Goodbye to Kotlin Companion Objects?

DevFeed: [The Evolution of Statics: Say Goodbye to Kotlin Companion Objects?](<https://devfeed.tech/articles/the-evolution-of-statics-say-goodbye-to-kotlin-companion-objects-85014.md>)

Original publisher: [Read original article](<https://proandroiddev.com/the-evolution-of-statics-say-goodbye-to-kotlin-companion-objects-dbe625b92896?source=rss-711ab22c5c77------2>)

Author: Nav Singh

Published: 2026-10-11T02:28:53Z

Content type: tutorial

Language: en

Sources: [Nav Singh](<https://devfeed.tech/sources/stories-by-nav-singh-on-medium.md>)

Topics: [extension property](<https://devfeed.tech/topics/extension-property.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [class](<https://devfeed.tech/topics/class.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [interface implementation](<https://devfeed.tech/topics/interface-implementation.md>)

Tags: [androiddev](<https://devfeed.tech/tags/androiddev.md>), [block](<https://devfeed.tech/tags/block.md>), [blocks](<https://devfeed.tech/tags/blocks.md>), [bytecode](<https://devfeed.tech/tags/bytecode.md>), [class](<https://devfeed.tech/tags/class.md>), [classes](<https://devfeed.tech/tags/classes.md>), [companion](<https://devfeed.tech/tags/companion.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [cross](<https://devfeed.tech/tags/cross.md>), [extension](<https://devfeed.tech/tags/extension.md>), [extensions](<https://devfeed.tech/tags/extensions.md>), [factory](<https://devfeed.tech/tags/factory.md>), [implement](<https://devfeed.tech/tags/implement.md>), [interface](<https://devfeed.tech/tags/interface.md>), [interop](<https://devfeed.tech/tags/interop.md>), [java](<https://devfeed.tech/tags/java.md>), [jvm](<https://devfeed.tech/tags/jvm.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [memory](<https://devfeed.tech/tags/memory.md>), [module](<https://devfeed.tech/tags/module.md>), [new-features](<https://devfeed.tech/tags/new-features.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [static](<https://devfeed.tech/tags/static.md>)

### AI overview

The excerpt presents Kotlin 2.5.0-Beta1 companion blocks and companion extensions as experimental alternatives to companion objects. Companion blocks compile members directly as static bytecode on the parent class, allowing Java calls such as `User.createDefault()` without `@JvmStatic`; unlike companion objects, they cannot implement interfaces because they are not objects. Companion extensions add static-like members to a type from outside its declaration, with examples including third-party factories, configuration initializers, and domain constants; regular extension functions instead operate on instances. Trying the preview requires the JetBrains Bootstrap Repository, Kotlin 2.5.0-Beta1, JVM toolchain 21, and the `-Xcompanion-blocks` and `-Xcompanion-blocks-and-extensions` compiler flags.

### Source excerpt

AI generated image For years, we used companion object to group class-level members (constants, factory methods). However, companion objects are actual object singletons under the hood. This introduces memory overhead and causes friction when interoperating with Java (requiring @JvmStaticannotations). data class User(val name: String, val age: Int) { companion object { @JvmStatic fun createDefault(): User = User("Guest", 18) } }AI generated imageKotlin 2.5 introduces companion blocks and companion extensions: Companion Blocks: Drop the object keyword. On the JVM, they compile down directly into high-performance native static members. Companion Extensions: Let us attach new static-like methods or properties to any class from the outside, even classes inside external dependencies or standard Java SDKs we don't control. Companion Blocks vs. Companion Objects Under the Hood: A companion object creates a nested singleton subclass instantiation. A companion block compiles directly to static bytecode members on the parent class. Interface Limitation: Companion objects are still required if static-scoped layer needs to implement an interface. Companion blocks cannot implement interfaces because they are not real objects. Java Interop: Java code can call companion block members directly via User.createDefault(). Companion objects still require User.Companion.createDefault() unless decorated with @JvmStatic. Companion Extensions vs. Regular Extension Functions Call Site: Regular extensions require an existing instance (userInstance.isValid()). Companion extensions are invoked statically on the type itself (User.systemAdmin()). Use Cases: Regular extensions add instance operations (mapping, filtering, etc.). Companion extensions serve as third-party factories, cross-module configuration initializers, or domain constants. Implementation🛠 Setting Up the project Companion Blocks and Extensions are arriving as experimental features in Kotlin 2.5.0-Beta1 To try this out today, we

## The Art of Object-Oriented Programming

DevFeed: [The Art of Object-Oriented Programming](<https://devfeed.tech/articles/the-art-of-object-oriented-programming-64579.md>)

Original publisher: [Read original article](<https://hackernoon.com/the-art-of-object-oriented-programming?source=rss>)

Author: Syed Ahmer Shah

Published: 2026-10-04T11:53:47Z

Content type: tutorial

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>), [solid principles](<https://devfeed.tech/topics/solid-principles.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [class](<https://devfeed.tech/topics/class.md>), [object](<https://devfeed.tech/topics/object.md>), [Dependency injection](<https://devfeed.tech/topics/dependency-injection.md>)

Tags: [common-oop-design-mistakes](<https://devfeed.tech/tags/common-oop-design-mistakes.md>), [composition](<https://devfeed.tech/tags/composition.md>), [composition-over-inheritance](<https://devfeed.tech/tags/composition-over-inheritance.md>), [coupling](<https://devfeed.tech/tags/coupling.md>), [coupling-and-cohesion-in-oop](<https://devfeed.tech/tags/coupling-and-cohesion-in-oop.md>), [design-patterns](<https://devfeed.tech/tags/design-patterns.md>), [four-pillars-of-oop](<https://devfeed.tech/tags/four-pillars-of-oop.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [object-oriented-programming](<https://devfeed.tech/tags/object-oriented-programming.md>), [oop-design-principles](<https://devfeed.tech/tags/oop-design-principles.md>), [oop-principles](<https://devfeed.tech/tags/oop-principles.md>), [polymorphism](<https://devfeed.tech/tags/polymorphism.md>), [programming](<https://devfeed.tech/tags/programming.md>)

### AI overview

A practical tutorial explains object-oriented programming through classes, objects, state, behavior, encapsulation, abstraction, inheritance, and polymorphism. It compares composition with inheritance and discusses association, aggregation, coupling, cohesion, and common design mistakes, using code examples to show how responsibilities can be separated in a software system.

### Source excerpt

Understand OOP from classes and objects to composition, inheritance, polymorphism, coupling, and cohesion with practical examples.

## Object-Oriented Programming (OOP) in Python

DevFeed: [Object-Oriented Programming (OOP) in Python](<https://devfeed.tech/articles/object-oriented-programming-oop-in-python-60468.md>)

Original publisher: [Read original article](<https://realpython.com/python3-object-oriented-programming/>)

Author: David Amos

Published: 2026-09-26T14:00:00Z

Content type: tutorial

Language: en

Sources: [Real Python](<https://devfeed.tech/sources/real-python.md>)

Topics: [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [Python](<https://devfeed.tech/topics/python.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [object](<https://devfeed.tech/topics/object.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>)

Tags: [class](<https://devfeed.tech/tags/class.md>), [classes](<https://devfeed.tech/tags/classes.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [oop](<https://devfeed.tech/tags/oop.md>), [programming](<https://devfeed.tech/tags/programming.md>), [python](<https://devfeed.tech/tags/python.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>)

### AI overview

This tutorial introduces object-oriented programming in Python, explaining how classes define objects and how objects group data with methods. It covers inheritance, encapsulation, abstraction, polymorphism, and creating instances from classes.

### Source excerpt

Learn object-oriented programming in Python: the OOP paradigm, classes and inheritance, and how to instantiate objects from a class.

## JEP targeted to JDK 28: 401: Value Objects (Preview)

DevFeed: [JEP targeted to JDK 28: 401: Value Objects (Preview)](<https://devfeed.tech/articles/jep-targeted-to-jdk-28-401-value-objects-preview-55597.md>)

Original publisher: [Read original article](<https://inside.java/2026/09/20/jep401-target-jdk28/>)

Author: Dan Smith

Published: 2026-09-20T00:00:00Z

Content type: article

Language: en

Sources: [Inside Java](<https://devfeed.tech/sources/inside-java.md>)

Topics: [Java](<https://devfeed.tech/topics/java.md>), [JEP-401](<https://devfeed.tech/topics/jep-401.md>), [Project Valhalla](<https://devfeed.tech/topics/project-valhalla.md>), [openjdk](<https://devfeed.tech/topics/openjdk.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>)

Tags: [jdk-28](<https://devfeed.tech/tags/jdk-28.md>), [jep](<https://devfeed.tech/tags/jep.md>), [preview](<https://devfeed.tech/tags/preview.md>), [project-valhalla](<https://devfeed.tech/tags/project-valhalla.md>), [value-objects](<https://devfeed.tech/tags/value-objects.md>)

### AI overview

JEP 401 proposes preview support in JDK 28 for value objects: instances of explicitly declared `value` classes are immutable and have no identity, so `==` compares their field values. This can let JVMs flatten references in fields and arrays or scalarize them in local variables, potentially reducing memory use and pointer loads; the JVM chooses which optimizations to apply, and no particular layout is guaranteed. Preview features are disabled by default and must be enabled at compile and run time. The proposal covers 30 Platform API value classes, while `String` remains an identity class. Identity-sensitive operations such as synchronization are unsupported for value objects. Migration can affect code relying on distinct instances, locking, serialization, reflection or garbage-collection APIs; non-record value classes implementing `Serializable` need `writeReplace` and `readResolve`. Use `equals` to test whether instances represent the same value, since it may differ from `==`.

### Source excerpt

The following JEP is targeted to JDK 28: 401: Value Objects (Preview)

## Code Smell 321 - Getter Piggybacking

DevFeed: [Code Smell 321 - Getter Piggybacking](<https://devfeed.tech/articles/code-smell-321-getter-piggybacking-18228.md>)

Original publisher: [Read original article](<https://maximilianocontieri.com/code-smell-321-getter-piggybacking>)

Author: Maxi Contieri

Published: 2026-08-20T02:51:49Z

Content type: article

Language: en

Sources: [Maximiliano Contieri - Software Design](<https://devfeed.tech/sources/maximiliano-contieri-software-design.md>)

Topics: [business logic](<https://devfeed.tech/topics/business-logic.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>)

Tags: [business-logic](<https://devfeed.tech/tags/business-logic.md>), [code-smell](<https://devfeed.tech/tags/code-smell.md>), [comparison](<https://devfeed.tech/tags/comparison.md>), [design](<https://devfeed.tech/tags/design.md>), [domain](<https://devfeed.tech/tags/domain.md>), [inside](<https://devfeed.tech/tags/inside.md>), [intermediate](<https://devfeed.tech/tags/intermediate.md>), [object](<https://devfeed.tech/tags/object.md>)

### AI overview

The smell is reusing a getter as a shortcut for business logic: callers fetch a value and implement comparisons outside the object that owns its meaning. This scatters rules, weakens encapsulation, hides domain knowledge, and makes refactoring fragile. Put the behavior or comparison in a method on the object, and have callers ask it the relevant question; reserve getters for legitimate reading such as rendering. The excerpt recommends manual detection: look for the same getter used in comparisons or filters at multiple external call sites. DTOs are not presented as an exception. The supplied text is an excerpt and does not include full examples or the complete discussion.

### Source excerpt

TL;DR: Don't reuse an existing getter to bolt on new business logic from outside the object. Problems 😔 Duplicated business rules Broken encapsulation Scattered comparison logic Hidden domain kn

## Aimy Captcha-Less Form Guard: The Anti-Bot Plugin That Hands Bots the Keys

DevFeed: [Aimy Captcha-Less Form Guard: The Anti-Bot Plugin That Hands Bots the Keys](<https://devfeed.tech/articles/aimy-captcha-less-form-guard-the-anti-bot-plugin-that-hands-bots-the-keys-91446.md>)

Original publisher: [Read original article](<https://www.vulncheck.com/blog/aimy-captcha-less-form-guard-object-injection>)

Author: Valentin Lobstein (Chocapikk)

Published: 2026-07-30T00:00:00Z

Content type: news

Language: en

Sources: [VulnCheck](<https://devfeed.tech/sources/vulncheck.md>)

Topics: [Encryption](<https://devfeed.tech/topics/encryption.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [CVE-2026-58138](<https://devfeed.tech/topics/cve-2026-58138.md>)

Tags: [base64](<https://devfeed.tech/tags/base64.md>), [bot](<https://devfeed.tech/tags/bot.md>), [bots](<https://devfeed.tech/tags/bots.md>), [bypass](<https://devfeed.tech/tags/bypass.md>), [captcha](<https://devfeed.tech/tags/captcha.md>), [code](<https://devfeed.tech/tags/code.md>), [code-execution](<https://devfeed.tech/tags/code-execution.md>), [form](<https://devfeed.tech/tags/form.md>), [initial-access](<https://devfeed.tech/tags/initial-access.md>), [joomla](<https://devfeed.tech/tags/joomla.md>), [keys](<https://devfeed.tech/tags/keys.md>), [less](<https://devfeed.tech/tags/less.md>), [object](<https://devfeed.tech/tags/object.md>), [php](<https://devfeed.tech/tags/php.md>), [plugin](<https://devfeed.tech/tags/plugin.md>), [remote](<https://devfeed.tech/tags/remote.md>), [remote-code-execution](<https://devfeed.tech/tags/remote-code-execution.md>), [xor](<https://devfeed.tech/tags/xor.md>)

### AI overview

CVE-2026-65883 affects Aimy Captcha-Less Form Guard 18.0-20.0: on every protected public form, unauthenticated input is base64-decoded, XOR-decoded, then passed to PHP `unserialize()` without an integrity check. Because each form exposes ciphertext for a known token, an attacker can recover enough of the repeating-key stream to forge tokens and bypass the captcha on all Joomla versions. On Joomla 3.9-5.2.1, the Joomla `FormattedtextLogger` gadget can turn the object injection into web-user remote code execution; Joomla 5.2.2 hardens that gadget, but does not remove the plugin flaw or rule out other site-provided gadgets. Aimy fixed the deserialization sink in 20.1 by switching to `json_decode()`, which blocks object injection but still permits token forgery and captcha bypass because the token remains unsigned. Update the plugin to 20.1; updating Joomla to 5.2.2 or later removes this particular RCE chain, not the underlying plugin vulnerability. The PRO edition was not tested.

### Source excerpt

VulnCheck's Initial Access Intelligence team details an unauthenticated PHP object injection in the Aimy Captcha-Less Form Guard plugin for Joomla, where a repeating-key XOR published alongside its own ciphertext turns every protected form into an unserialize() sink and, on Joomla 3.9 through 5.2.1, into remote code execution.

## Understanding Mixin Classes in Python

DevFeed: [Understanding Mixin Classes in Python](<https://devfeed.tech/articles/understanding-mixin-classes-in-python-4372.md>)

Original publisher: [Read original article](<https://realpython.com/courses/understanding-mixin-classes-in-python/>)

Author: Real Python

Published: 2026-07-14T14:00:00Z

Content type: tutorial

Language: en

Sources: [Real Python](<https://devfeed.tech/sources/real-python.md>)

Topics: [Python](<https://devfeed.tech/topics/python.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [how-to](<https://devfeed.tech/tags/how-to.md>), [oop](<https://devfeed.tech/tags/oop.md>), [python](<https://devfeed.tech/tags/python.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>), [video](<https://devfeed.tech/tags/video.md>)

### AI overview

A video course on using Python mixin classes to share reusable behavior across classes without creating rigid inheritance hierarchies. It explains multiple inheritance, stateful mixins, method resolution order, and common design considerations.

### Source excerpt

Learn how to write reusable Python mixin classes, distinguish them from abstract base classes, and steer clear of common pitfalls.

## Managing Multi Table Inserts With Room

DevFeed: [Managing Multi Table Inserts With Room](<https://devfeed.tech/articles/managing-multi-table-inserts-with-room-22825.md>)

Original publisher: [Read original article](<http://androidessence.com/multi-table-inserts/>)

Author: Adam McNeilly

Published: 2026-04-25T00:00:00Z

Content type: article

Language: en

Sources: [Android Essence](<https://devfeed.tech/sources/android-essence.md>)

Topics: [Database](<https://devfeed.tech/topics/database.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>), [interface](<https://devfeed.tech/topics/interface.md>), [Dependency injection](<https://devfeed.tech/topics/dependency-injection.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [database](<https://devfeed.tech/tags/database.md>), [dependency-injection](<https://devfeed.tech/tags/dependency-injection.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [oop](<https://devfeed.tech/tags/oop.md>)

### AI overview

This article explains how to handle multi-table inserts in Room when entities have nested dependencies. It first considers separate DAO interfaces and a wrapper class, then shows how interface inheritance can centralize insertion logic and let dependent DAOs reuse it.

### Source excerpt

A properly relational database may have a type that appears referenced multiple times. In my SpaceNerd playground app, that is the Country object. An Agency has a country, and an Agency is a dependency of a Launch, of a Space Station, and likely more types to come. How do I enforce that any time I insert an Agency, I also insert the Countries associated with it? That's what this blog post sets out to explore, and the answer is much simpler than I thought when I started.

## Object Oriented Programming - The Key Terms

DevFeed: [Object Oriented Programming - The Key Terms](<https://devfeed.tech/articles/object-oriented-programming-the-key-terms-34688.md>)

Original publisher: [Read original article](<https://newsletter.systemdesigncodex.com/p/object-oriented-programming-the-key>)

Author: Saurabh Dashora

Published: 2026-03-24T08:38:43Z

Content type: article

Language: en

Sources: [System Design Codex](<https://devfeed.tech/sources/system-design-codex.md>)

Topics: [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [implementation](<https://devfeed.tech/topics/implementation.md>), [interface](<https://devfeed.tech/topics/interface.md>)

Tags: [abstraction](<https://devfeed.tech/tags/abstraction.md>), [concepts](<https://devfeed.tech/tags/concepts.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [maintainability](<https://devfeed.tech/tags/maintainability.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [polymorphism](<https://devfeed.tech/tags/polymorphism.md>), [programming](<https://devfeed.tech/tags/programming.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

This tutorial introduces object-oriented programming through four principles: abstraction, encapsulation, inheritance, and polymorphism. It explains how abstraction hides implementation details, encapsulation controls access to data and methods, and inheritance supports reuse and hierarchical relationships. The supplied text begins its discussion of polymorphism but is truncated.

### Source excerpt

The essential concepts

## 12 OOP Concepts EVERY Developer Should Know

DevFeed: [12 OOP Concepts EVERY Developer Should Know](<https://devfeed.tech/articles/12-oop-concepts-every-developer-should-know-33559.md>)

Original publisher: [Read original article](<https://blog.algomaster.io/p/12-oop-concepts-every-developer-should-know>)

Author: Ashish Pratap Singh

Published: 2026-02-12T04:27:26Z

Content type: tutorial

Language: en

Sources: [AlgoMaster Newsletter](<https://devfeed.tech/sources/algomaster-newsletter.md>)

Topics: [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Code](<https://devfeed.tech/topics/code.md>), [interface](<https://devfeed.tech/topics/interface.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>), [App](<https://devfeed.tech/topics/app.md>)

Tags: [class](<https://devfeed.tech/tags/class.md>), [classes](<https://devfeed.tech/tags/classes.md>), [code](<https://devfeed.tech/tags/code.md>), [concepts](<https://devfeed.tech/tags/concepts.md>), [developer](<https://devfeed.tech/tags/developer.md>), [interface](<https://devfeed.tech/tags/interface.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [oop](<https://devfeed.tech/tags/oop.md>), [practical](<https://devfeed.tech/tags/practical.md>), [programming](<https://devfeed.tech/tags/programming.md>), [real-world](<https://devfeed.tech/tags/real-world.md>)

### AI overview

An introductory tutorial on object-oriented programming explains how classes, objects, and interfaces organize state and behavior. It uses real-world examples such as users, orders, payments, and payment gateways, and notes that these concepts are relevant to low-level design interviews.

### Source excerpt

Key Object-Oriented Programming Concepts

## The Liskov Substitution Principle does more than you think

DevFeed: [The Liskov Substitution Principle does more than you think](<https://devfeed.tech/articles/the-liskov-substitution-principle-does-more-than-you-think-25507.md>)

Original publisher: [Read original article](<https://buttondown.com/hillelwayne/archive/the-liskov-substitution-principle-does-more-than/>)

Author: Hillel Wayne

Published: 2026-01-06T16:51:26Z

Content type: article

Language: en

Sources: [Newsletter feed for Hillel Wayne's Newsletter](<https://devfeed.tech/sources/newsletter-feed-for-hillel-wayne-s-newsletter.md>)

Topics: [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [superclass](<https://devfeed.tech/topics/superclass.md>)

Tags: [call](<https://devfeed.tech/tags/call.md>), [code](<https://devfeed.tech/tags/code.md>), [example](<https://devfeed.tech/tags/example.md>), [execution](<https://devfeed.tech/tags/execution.md>), [f](<https://devfeed.tech/tags/f.md>), [history](<https://devfeed.tech/tags/history.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [invariants](<https://devfeed.tech/tags/invariants.md>), [logic-for-programmers](<https://devfeed.tech/tags/logic-for-programmers.md>), [lsp](<https://devfeed.tech/tags/lsp.md>), [oop](<https://devfeed.tech/tags/oop.md>), [operator](<https://devfeed.tech/tags/operator.md>), [paper](<https://devfeed.tech/tags/paper.md>), [root](<https://devfeed.tech/tags/root.md>), [solid](<https://devfeed.tech/tags/solid.md>), [solid-principles](<https://devfeed.tech/tags/solid-principles.md>), [square](<https://devfeed.tech/tags/square.md>), [subtype](<https://devfeed.tech/tags/subtype.md>), [tests](<https://devfeed.tech/tags/tests.md>), [wing](<https://devfeed.tech/tags/wing.md>)

### AI overview

The excerpt presents Liskov substitution as a behavioral guarantee beyond merely using inheritance: any property that holds for a supertype should also hold for its subtype. It gives three conditions for correct subtyping: subtype methods must have equal or weaker preconditions and equal or stronger postconditions; the subtype must preserve the supertype's state invariants; and it must preserve its history properties, such as keeping an immutable field immutable. The author focuses on method contracts and says the first condition can be formally deduced, but the excerpt ends before showing that derivation.

### Source excerpt

Happy New Year! I'm done with the newsletter hiatus and am going to try updating weekly again. To ease into things a bit, I'll try to keep posts a little more off the cuff and casual for a while, at least until Logic for Programmers is done. Speaking of which, v0.13 should be out by the end of this month. So for this newsletter I want to talk about the Liskov Substitution Principle (LSP). Last week I read A SOLID Load of Bull by cryptographer Loupe Vaillant, where he argues the SOLID principles of OOP are not worth following. He makes an exception for LSP, but also claims that it's "just subtyping" and further: If I were trying really hard to be negative about the Liskov substitution principle, I would stress that it only applies when inheritance is involved, and inheritance is strongly discouraged anyway. LSP is more interesting than that! In the original paper, A Behavioral Notion of Subtyping, Barbara Liskov and Jeannette Wing start by defining a "correct" subtyping as follows: Subtype Requirement: Let ϕ(x) be a property provable about objects x of type T. Then ϕ(y) should be true for objects y of type S where S is a subtype of T. From then on, the paper determine what guarantees that a subtype is correct.1 They identify three conditions: Each of the subtype's methods has the same or weaker preconditions and the same or stronger postconditions as the corresponding supertype method.2 The subtype satisfies all state invariants of the supertype. The subtype satisfies all "history properties" of the supertype. 3 e.g. if a supertype has an immutable field, the subtype cannot make it mutable. (Later, Elisa Baniassad and Alexander Summers would realize these are equivalent to "the subtype passes all black-box tests designed for the supertype", which I wrote a little bit more about here.) I want to focus on the first rule about preconditions and postconditions. This refers to the method's contract. For a function f, f.Pre is what must be true going into the function, and

## ESP-IDF tutorial series: Object oriented programming in C

DevFeed: [ESP-IDF tutorial series: Object oriented programming in C](<https://devfeed.tech/articles/esp-idf-tutorial-series-object-oriented-programming-in-c-13731.md>)

Original publisher: [Read original article](<https://developer.espressif.com/blog/2025/10/oop_with_c/>)

Author: John Lee

Published: 2025-10-03T00:00:00Z

Content type: tutorial

Language: en

Sources: [Blog on Developer Portal](<https://devfeed.tech/sources/blog-on-developer-portal.md>)

Topics: [C](<https://devfeed.tech/topics/c.md>), [ESP-IDF](<https://devfeed.tech/topics/esp-idf.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [blog](<https://devfeed.tech/tags/blog.md>), [c](<https://devfeed.tech/tags/c.md>), [esp-idf](<https://devfeed.tech/tags/esp-idf.md>), [esp32c3](<https://devfeed.tech/tags/esp32c3.md>), [object](<https://devfeed.tech/tags/object.md>), [oop](<https://devfeed.tech/tags/oop.md>), [programming](<https://devfeed.tech/tags/programming.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>)

### AI overview

This tutorial explains how ESP-IDF applies object-oriented programming principles in C using structs, opaque pointers, handles, function pointers, and modular design. It also discusses encapsulation, reusable components, and examples involving HTTP servers and I²C buses.

### Source excerpt

This article explains how ESP-IDF brings object-oriented programming principles into C by using structs, opaque pointers, and handles to enforce encapsulation and modularity. It shows how components like HTTP servers and I²C buses are managed through handles that represent distinct objects for configuration and operation, and compares this approach to Python and C++.

## Write Change-Resilient Code With Domain Objects

DevFeed: [Write Change-Resilient Code With Domain Objects](<https://devfeed.tech/articles/write-change-resilient-code-with-domain-objects-23860.md>)

Original publisher: [Read original article](<http://testing.googleblog.com/2024/09/write-change-resilient-code-with-domain.html>)

Author: Google Testing Bloggers (noreply@blogger.com)

Published: 2024-09-04T12:56:00Z

Content type: article

Language: en

Sources: [Google Testing Blog](<https://devfeed.tech/sources/google-testing-blog.md>)

Topics: [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [interface](<https://devfeed.tech/topics/interface.md>), [solid principles](<https://devfeed.tech/topics/solid-principles.md>), [class](<https://devfeed.tech/topics/class.md>)

Tags: [amy-fu](<https://devfeed.tech/tags/amy-fu.md>), [avoid](<https://devfeed.tech/tags/avoid.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [blocks](<https://devfeed.tech/tags/blocks.md>), [business](<https://devfeed.tech/tags/business.md>), [cases](<https://devfeed.tech/tags/cases.md>), [change](<https://devfeed.tech/tags/change.md>), [changes](<https://devfeed.tech/tags/changes.md>), [class](<https://devfeed.tech/tags/class.md>), [classes](<https://devfeed.tech/tags/classes.md>), [code](<https://devfeed.tech/tags/code.md>), [code-health](<https://devfeed.tech/tags/code-health.md>), [color](<https://devfeed.tech/tags/color.md>), [configure](<https://devfeed.tech/tags/configure.md>), [delivery](<https://devfeed.tech/tags/delivery.md>), [demand](<https://devfeed.tech/tags/demand.md>), [display](<https://devfeed.tech/tags/display.md>), [domain](<https://devfeed.tech/tags/domain.md>), [download](<https://devfeed.tech/tags/download.md>), [tott](<https://devfeed.tech/tags/tott.md>), [write](<https://devfeed.tech/tags/write.md>)

### AI overview

The excerpt argues that code built around stable product concepts can better accommodate changing requirements. In its gPizza example, a single `deliverPizza` method may lead to a growing set of methods as drinks and other offerings are added. It recommends modeling common ideas shared across related use cases with domain objects, rather than encoding each requirement as a separate behavior. The excerpt defines a use case as a behavior serving a business requirement and begins suggesting questions for identifying a suitable domain object, but cuts off before completing that guidance.

### Source excerpt

This is another post in our Code Health series. A version of this post originally appeared in Google bathrooms worldwide as a Google Testing on the Toilet episode. You can download a printer-friendly version to display in your office. By Amy Fu Although a product's requirements can change often, its fundamental ideas usually change slowly. This leads to an interesting insight: if we write code that matches the fundamental ideas of the product, it will be more likely to survive future product changes. Domain objects are building blocks (such as classes and interfaces) in our code that match the fundamental ideas of the product. Instead of writing code to match the desired behavior for the product's requirements ("configure text to be white"), we match the underlying idea ("text color settings"). For example, imagine you're part of the gPizza team, which sells tasty, fresh pizzas to feed hungry Googlers. Due to popular demand, your team has decided to add a delivery service. Without domain objects, the quickest path to pizza delivery is to simply create a deliverPizza method: public class DeliveryService { public void deliverPizza(List<Pizza> pizzas) { ... } } Although this works well at first, what happens if gPizza expands its offerings to other foods? You could add a new method: public void deliverWithDrinks(List<Pizza> pizzas, List<Drink> drinks) { ... } But as your list of requirements grows (snacks, sweets, etc.), you'll be stuck adding more and more methods. How can you change your initial implementation to avoid this continued maintenance burden? You could add a domain object that models the product's ideas, instead of its requirements: A use case is a specific behavior that helps the product satisfy its business requirements. (In this case, "Deliver pizzas so we make more money".) A domain object represents a common idea that is shared by several similar use cases. To identify the appropriate domain object, ask yourself: What related use cases does the produc

[Next page](<https://devfeed.tech/topics/oop.md?cursor=WyIyMDI0LTA5LTA0VDEyOjU2OjAwKzAwOjAwIiwgIjE3Nzc3NzRkLTVlNzQtNGM3My1hODg1LTUzNmVjZWZhYWE3MSJd>)