# Inheritance

Inheritance is an object-oriented programming concept in which classes inherit, reuse, extend, or modify state and behavior from other classes.

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

## Not Every Inventory Item Needs to Be a UObject

DevFeed: [Not Every Inventory Item Needs to Be a UObject](<https://devfeed.tech/articles/not-every-inventory-item-needs-to-be-a-uobject-115705.md>)

Original publisher: [Read original article](<https://hackernoon.com/not-every-inventory-item-needs-to-be-a-uobject?source=rss>)

Author: Ilia Zherlitsin

Published: 2026-11-03T19:00:35Z

Content type: article

Language: en

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

Topics: [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [Unreal Engine](<https://devfeed.tech/topics/unreal-engine.md>), [object](<https://devfeed.tech/topics/object.md>), [class](<https://devfeed.tech/topics/class.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>)

Tags: [behavior](<https://devfeed.tech/tags/behavior.md>), [blueprint](<https://devfeed.tech/tags/blueprint.md>), [boundary](<https://devfeed.tech/tags/boundary.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [cache](<https://devfeed.tech/tags/cache.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [datatable](<https://devfeed.tech/tags/datatable.md>), [design](<https://devfeed.tech/tags/design.md>), [flashlight](<https://devfeed.tech/tags/flashlight.md>), [framework](<https://devfeed.tech/tags/framework.md>), [game-development](<https://devfeed.tech/tags/game-development.md>), [game-programming](<https://devfeed.tech/tags/game-programming.md>), [hackernoon-top-story](<https://devfeed.tech/tags/hackernoon-top-story.md>), [hybrid](<https://devfeed.tech/tags/hybrid.md>), [inventory](<https://devfeed.tech/tags/inventory.md>), [isk](<https://devfeed.tech/tags/isk.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [state](<https://devfeed.tech/tags/state.md>), [unreal-engine](<https://devfeed.tech/tags/unreal-engine.md>)

### AI overview

ISK uses a hybrid inventory model: every item has a stable key and an entry holding common state such as count, flags, and position, while only items needing custom behavior or state receive a runtime UItem. This avoids object lifecycle work for simple stacks and keeps common state authoritative in one place. Runtime UItems read common data through IItemDataProvider and store only item-specific state; saving captures entry data separately from optional ISaveProvider payloads, and replication sends entries through a Fast Array and UItems as subobjects. Transfers preserve the logical key while duplicating runtime objects into the destination inventory and rebinding their provider. The design adds ownership, binding, save, and replication rules for runtime items; a fully data-only design is also viable, while an all-UObject model may suit inventories where nearly every item needs independent behavior.

### Source excerpt

A hybrid Unreal Engine inventory design that keeps common item state in entries and creates UObjects only when items need custom behavior or state.

## 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.

## 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.

## Single and Double Underscores in Python Names

DevFeed: [Single and Double Underscores in Python Names](<https://devfeed.tech/articles/single-and-double-underscores-in-python-names-100533.md>)

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

Author: Leodanis Pozo Ramos

Published: 2026-10-26T14: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>), [Learning](<https://devfeed.tech/topics/learning.md>), [Tutorial](<https://devfeed.tech/topics/tutorial.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [identifier](<https://devfeed.tech/topics/identifier.md>)

Tags: [api-design](<https://devfeed.tech/tags/api-design.md>), [apis](<https://devfeed.tech/tags/apis.md>), [classes](<https://devfeed.tech/tags/classes.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

Python uses underscores to signal intent rather than enforce access restrictions: a single leading underscore marks names as non-public, while wildcard imports omit them unless they appear in `__all__`; direct imports can still access them. Double leading underscores trigger class-name mangling, which helps prevent accidental attribute or method collisions in subclasses, but does not make members inaccessible. A trailing underscore can avoid clashing with keywords or built-ins. Double underscores at both ends identify documented special methods and attributes used by Python, such as `__len__`. The article also covers underscore placeholders and named-tuple members, whose leading underscores help avoid field-name conflicts.

### Source excerpt

Learn Python naming conventions with single and double underscores to design APIs, create safe classes, and prevent name clashes.

## 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.

## Representative Line: A Diamond in the Rough

DevFeed: [Representative Line: A Diamond in the Rough](<https://devfeed.tech/articles/representative-line-a-diamond-in-the-rough-87231.md>)

Original publisher: [Read original article](<https://thedailywtf.com/articles/a-diamond-in-the-rough>)

Author: Remy Porter

Published: 2026-10-14T06:30:00Z

Content type: article

Language: en

Sources: [The Daily WTF](<https://devfeed.tech/sources/the-daily-wtf.md>)

Topics: [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [class](<https://devfeed.tech/topics/class.md>), [subclass](<https://devfeed.tech/topics/subclass.md>)

Tags: [classes](<https://devfeed.tech/tags/classes.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [representative-line](<https://devfeed.tech/tags/representative-line.md>)

### AI overview

The article explains C++ virtual inheritance as a way to address the diamond problem, then describes code where using virtual inheritance on a final class has no effect because the class cannot be inherited from.

### Source excerpt

Mandy's co-worker recently learned about virtual inheritance in C++. It's become their new favorite button to push, and they only use virtual inheritance. Virtual inheritance is one workaround for the "diamond problem", where you have an inheritance tree that "recombines" via multiple inheritance: when a child class has a Hapsburg-esque parentage, it's hard to decide which inherited methods are being invoked or overridden. In C++, imagine you have class A, which gets derived into classes B and C. Class D then uses multiple inheritance to inherit from B and C. In practice, this means that D inherits from A twice, and would have two internal copies of all of A's members. If, on the other hand, you have B and C inherit virtually (class B : public virtual A), then class D will only actually inherit a single copy of A. If you're reading this and going, "Boy, this just sounds like another reason to avoid multiple inheritance," you're probably right. The important thing, though, is inheriting virtually impacts how your child classes will inherit. It only matters if you have child classes. Which brings us back to Mandy's co-worker. He read somewhere that defaulting to virtual inheritance all the time was safer, so he did that all the time. All. The. Time. Including in this case: class SomeSpecificDerivedClass final : public virtual SomeBaseClass The class here is marked final. It can't be inherited from. The use of virtual accomplishes nothing. [Advertisement] BuildMaster allows you to create a self-service release management platform that allows different teams to manage their applications. Explore how!

## CodeSOD: A Type of Type Safety

DevFeed: [CodeSOD: A Type of Type Safety](<https://devfeed.tech/articles/codesod-a-type-of-type-safety-85187.md>)

Original publisher: [Read original article](<https://thedailywtf.com/articles/a-type-of-type-safety>)

Author: Remy Porter

Published: 2026-10-12T06:30:00Z

Content type: article

Language: en

Sources: [The Daily WTF](<https://devfeed.tech/sources/the-daily-wtf.md>)

Topics: [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [typesafety](<https://devfeed.tech/topics/typesafety.md>)

Tags: [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [code](<https://devfeed.tech/tags/code.md>), [codesod](<https://devfeed.tech/tags/codesod.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [polymorphism](<https://devfeed.tech/tags/polymorphism.md>), [type-safety](<https://devfeed.tech/tags/type-safety.md>), [type-system](<https://devfeed.tech/tags/type-system.md>)

### AI overview

The article critiques a C++ codebase that uses runtime type checks and casts to restrict behavior based on object types. It explains how this approach misuses C++ casting and contrasts it with using polymorphism and dynamic dispatch to model the domain.

### Source excerpt

For some godawful reason, people like to explain object oriented concepts via analogy to biological taxonomies. I suppose it's easy to understand an "is-a" relationship (a cat is a mammal), but the down side is you get a complex and increasingly leaky analogy that over-emphasizes the importance of inheritance. That's not to slight Alan's choice of using it to anoymize today's code. It's just a broad frustration on my part. In any case, Alan has been working in a C++ codebase that's written by people who maybe don't fully understand all the key object oriented concepts. That's why you get code like this: /* * If possible, steal tentacle from the given animal. */ void Animal::StealTentacle(Animal *animal) { // only Octopus and Squid can have tentacles if (!IS_INSTANCE_OF(this, Octopus) && !IS_INSTANCE_OF(this, Squid)) { return; } Limb *limb = animal->mLimbs->GetFirstTentacle(); if (limb) { limb->AttachToAnimal(this); // . . . This function takes a raw pointer to an Animal object. If that pointer is not an Octopus or a Squid, we bail. Otherwise, we're going to take its tentacle, and do stuff with it. Now, this is a pretty clear example of the type switch anti-pattern. Instead of using the type system and polymorphism to enforce restrictions, we instead do runtime type checks. But wait a second, what's going on in that IS_INSTANCE_OF? // I've noticed that dynamic_cast always returns a valid result when // casting an "objectPointer" of type "className". // Try casting it to a [Organism *] to force it to work. (?) #define IS_INSTANCE_OF(objectPointer, className) ((bool) (dynamic_cast<className *>(((Organism *) objectPointer)) != NULL)) #define IS_MEMBER_OF(objectPointer, className) IS_INSTANCE_OF(objectPointer, className) // temporary macro alias This code attempts to take an objectPointer and first, force it into a pointer to our base type (Organism), using a C-style cast. Now, in C++, C-style casts are a shorthand, and the compiler will, based on the context, attempt to

## 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.

## htmx 4.0: a Fetch-Based Rewrite, Built-In Morphing Swaps, and Explicit Attribute Inheritance

DevFeed: [htmx 4.0: a Fetch-Based Rewrite, Built-In Morphing Swaps, and Explicit Attribute Inheritance](<https://devfeed.tech/articles/htmx-4-0-a-fetch-based-rewrite-built-in-morphing-swaps-and-explicit-attribute-inheritance-42775.md>)

Original publisher: [Read original article](<https://www.infoq.com/news/2026/09/htmx-4-released/>)

Author: Daniel Curtis

Published: 2026-09-18T09:32:00Z

Content type: news

Language: en

Sources: [InfoQ](<https://devfeed.tech/sources/infoq.md>)

Topics: [htmx](<https://devfeed.tech/topics/htmx.md>), [fetch](<https://devfeed.tech/topics/fetch.md>), [Library](<https://devfeed.tech/topics/library.md>), [Document Object Model (DOM)](<https://devfeed.tech/topics/dom.md>), [Streaming](<https://devfeed.tech/topics/streaming.md>), [API](<https://devfeed.tech/topics/api.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>), [Ajax](<https://devfeed.tech/topics/ajax.md>), [CSS](<https://devfeed.tech/topics/css.md>), [npm](<https://devfeed.tech/topics/npm.md>), [WebSocket](<https://devfeed.tech/topics/websocket.md>)

Tags: [ajax](<https://devfeed.tech/tags/ajax.md>), [api](<https://devfeed.tech/tags/api.md>), [css](<https://devfeed.tech/tags/css.md>), [development](<https://devfeed.tech/tags/development.md>), [elements](<https://devfeed.tech/tags/elements.md>), [fetch](<https://devfeed.tech/tags/fetch.md>), [html](<https://devfeed.tech/tags/html.md>), [html5](<https://devfeed.tech/tags/html5.md>), [htmx](<https://devfeed.tech/tags/htmx.md>), [htmx-4-released](<https://devfeed.tech/tags/htmx-4-released.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [library](<https://devfeed.tech/tags/library.md>), [news](<https://devfeed.tech/tags/news.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [npm](<https://devfeed.tech/tags/npm.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [server-side-rendering](<https://devfeed.tech/tags/server-side-rendering.md>), [streaming](<https://devfeed.tech/tags/streaming.md>), [web-development](<https://devfeed.tech/tags/web-development.md>)

### AI overview

htmx 4.0 has been released as a major rewrite built on the fetch() API. It adds native streaming, built-in morphing swaps that preserve DOM state, multi-target updates, explicit attribute inheritance, standardized event names, and history refetching. The release is distributed under npm's next tag, while htmx 2.x remains supported.

### Source excerpt

htmx 4 has been released, featuring a transition from XMLHttpRequest to the fetch() API, enhancing streaming capabilities. Key updates include built-in morphing swaps for DOM state preservation and an hx-partial tag for cleaner updates. Attribute inheritance is now explicit, with event names standardized. The library maintains focus on minimal JavaScript while remaining popular among frameworks. By Daniel Curtis

## 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

## two mechanisms for dynamic type checks

DevFeed: [two mechanisms for dynamic type checks](<https://devfeed.tech/articles/two-mechanisms-for-dynamic-type-checks-35030.md>)

Original publisher: [Read original article](<https://wingolog.org/archives/2026/02/18/two-mechanisms-for-dynamic-type-checks>)

Author: Andy Wingo

Published: 2026-02-18T16:21:10Z

Content type: tutorial

Language: en

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

Topics: [virtual machines](<https://devfeed.tech/topics/virtual-machines.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [WebAssembly](<https://devfeed.tech/topics/web-assembly.md>), [JIT](<https://devfeed.tech/topics/jit.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>)

Tags: [cardelli](<https://devfeed.tech/tags/cardelli.md>), [cohen](<https://devfeed.tech/tags/cohen.md>), [dfs](<https://devfeed.tech/tags/dfs.md>), [display-hack](<https://devfeed.tech/tags/display-hack.md>), [dybvig](<https://devfeed.tech/tags/dybvig.md>), [scheme](<https://devfeed.tech/tags/scheme.md>), [vitek](<https://devfeed.tech/tags/vitek.md>), [wasm](<https://devfeed.tech/tags/wasm.md>), [webassembly](<https://devfeed.tech/tags/webassembly.md>)

### AI overview

This technical note explains two mechanisms for dynamic instance type checks in virtual machines with single inheritance. It describes DFS numbering when the type set is fixed and the display hack, based on per-type supertype arrays, when types can be added at run time.

### Source excerpt

Today, a very quick note on dynamic instance type checks in virtual machines with single inheritance. The problem is that given an object o whose type is t, you want to check if o actually is of some more specific type u. To my knowledge, there are two sensible ways to implement these type checks. if the set of types is fixed: dfs numbering Consider a set of types T := {t, u, ...} and a set of edges S := {<t|ε, u>, ...} indicating that t is the direct supertype of u, or ε if u is a top type. S should not contain cycles and is thus a direct acyclic graph rooted at ε. First, compute a pre-order and post-order numbering for each t in the graph by doing a depth-first search over S from ε. Something like this: def visit(t, counter): t.pre_order = counter counter = counter + 1 for u in S[t]: counter = visit(u, counter) t.post_order = counter return counter Then at run-time, when making an object of type t, you arrange to store the type's pre-order number (its tag) in the object itself. To test if the object is of type u, you extract the tag from the object and check if tag-u.pre_order mod 2n < u.post_order-u.pre_order. Two notes, probably obvious but anyway: one, you know the numbering for u at compile-time and so can embed those variables as immediates. Also, if the type has no subtypes, it can be a simple equality check. Note that this approach applies only if the set of types T is fixed. This is the case when statically compiling a WebAssembly module in a system that doesn't allow modules to be instantiated at run-time, like Wastrel. Interestingly, it can also be the case in JIT compilers, when modeling types inside the optimizer. if the set of types is unbounded: the display hack If types may be added to a system at run-time, maintaining a sorted set of type tags may be too much to ask. In that case, the standard solution is something I learned of as the display hack, but whose name is apparently ungooglable. It is described in a 4-page technical note by Norman H. Coh

## Unconventional PostgreSQL Optimizations

DevFeed: [Unconventional PostgreSQL Optimizations](<https://devfeed.tech/articles/unconventional-postgresql-optimizations-33925.md>)

Original publisher: [Read original article](<https://hakibenita.com/postgresql-unconventional-optimizations>)

Author: Haki Benita

Published: 2026-01-19T22:00:00Z

Content type: tutorial

Language: en

Sources: [Haki Benita](<https://devfeed.tech/sources/haki-benita.md>)

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [Database](<https://devfeed.tech/topics/database.md>), [Query (disambiguation)](<https://devfeed.tech/topics/query.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>)

Tags: [articles](<https://devfeed.tech/tags/articles.md>), [database-optimization](<https://devfeed.tech/tags/database-optimization.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [partitioning](<https://devfeed.tech/tags/partitioning.md>), [performance](<https://devfeed.tech/tags/performance.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [query](<https://devfeed.tech/tags/query.md>), [vacuum](<https://devfeed.tech/tags/vacuum.md>)

### AI overview

This article presents unconventional PostgreSQL optimization techniques. It explains how constraint exclusion can use check constraints to avoid scanning a table for impossible conditions, while noting that enabling it broadly can add planning overhead; partition pruning is enabled by default for partitioned tables.

### Source excerpt

When it comes to database optimization, developers often reach for the same old tools: rewrite the query slightly differently, slap an index on a column, denormalize, analyze, vacuum, cluster, repeat. Conventional techniques are effective, but sometimes being creative can really pay off!

## Bazel rule extensions

DevFeed: [Bazel rule extensions](<https://devfeed.tech/articles/bazel-rule-extensions-25413.md>)

Original publisher: [Read original article](<https://smileykeith.com/2025/10/31/bazel-rule-extensions/>)

Author: Keith Smiley

Published: 2025-10-31T17:00:00Z

Content type: article

Language: en

Sources: [Keith Smiley](<https://devfeed.tech/sources/keith-smiley.md>)

Topics: [bazel](<https://devfeed.tech/topics/bazel.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [extend](<https://devfeed.tech/topics/extend.md>)

Tags: [actions](<https://devfeed.tech/tags/actions.md>), [bazel](<https://devfeed.tech/tags/bazel.md>), [class](<https://devfeed.tech/tags/class.md>), [custom](<https://devfeed.tech/tags/custom.md>), [existing](<https://devfeed.tech/tags/existing.md>), [extend](<https://devfeed.tech/tags/extend.md>), [extensions](<https://devfeed.tech/tags/extensions.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [object-oriented-programming](<https://devfeed.tech/tags/object-oriented-programming.md>), [providers](<https://devfeed.tech/tags/providers.md>), [use-case](<https://devfeed.tech/tags/use-case.md>), [use-cases](<https://devfeed.tech/tags/use-cases.md>)

### AI overview

Bazel 8.0 rule extensions let a new rule inherit an existing rule, call its implementation with `ctx.super()`, then alter providers, add a transition, or attach aspects. The excerpt shows post-processing a rule's output with a sort action; normalizing macOS and Linux debug outputs into one `OutputGroupInfo` group; adding a Python version transition to `py_wheel`; and applying Apple platform transitions to Swift libraries. The Swift example requires transition attributes and can use `select()` in a macro to preserve tvOS dependencies. Limitations include restricted attribute overrides, the requirement that `parent` be a rule rather than a macro, and difficulty modifying existing actions such as adding `-ftime-trace` output.

### Source excerpt

One of Bazel's best features is being able to easily write custom rules specific to your project. This is great for many use cases, but when what you really want is to enhance the behavior of existing rules, historically your options have been limited. What you would often do is wrap the existing rule in a macro, and add some number of custom rules to try and achieve the desired effect. When really what you want is to edit the existing rule, without having to re-implement all of its functionality (or maintain a fork). With Bazel 8.0, Googlers added a few new ways to extend existing rules that can help with this use case. In this post we will look at the aptly named rule extensions feature and some practical use cases I have found for it. Basic rule extensions Rule extensions allow you to inherit the behavior of an existing rule, similar to class inheritance in object-oriented programming. Importantly you can make a few modifications to augment the behavior of the rule to your liking. Let's say you have a rule that concatenates the given srcs: def _foo_impl(ctx): output = ctx.actions.declare_file("output.txt") ctx.actions.run_shell( inputs = ctx.files.srcs, outputs = [output], command = "cat {} > {}".format(" ".join([src.path for src in ctx.files.srcs]), output.path), ) return [DefaultInfo(files = depset([output]))] foo = rule( implementation = _foo_impl, attrs = { "srcs": attr.label_list(allow_files = True), }, ) Now let's assume in your project, you want the output file to be sorted. If you own the original rule you could of course change _foo_impl to handle that for you, but if you are relying on a more complex upstream rule, you may not have that luxury. Here's how we can extend this to post-process the file it produces: def _bar_impl(ctx): providers = ctx.super() # Invoke 'foo' and get the providers # NOTE: This assumes there's always only the provider we want. original_output = providers[0].files.to_list()[0] new_output = ctx.actions.declare_file("new_output.tx

## Inside Burst's Test Interceptors

DevFeed: [Inside Burst's Test Interceptors](<https://devfeed.tech/articles/inside-burst-s-test-interceptors-32245.md>)

Original publisher: [Read original article](<https://publicobject.com/2025/09/06/inside-bursts-test-interceptors/>)

Author: Jesse Wilson

Published: 2025-09-06T04:27:03Z

Content type: article

Language: en

Sources: [Public Object](<https://devfeed.tech/sources/public-object.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [compiler](<https://devfeed.tech/tags/compiler.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [tests](<https://devfeed.tech/tags/tests.md>)

### AI overview

This article explains Burst's test interceptors, which provide JUnit-rule-like capabilities for connecting lifecycle behavior to test execution. It describes how Burst, a Kotlin Multiplatform library, uses a compiler plugin instead of reflection and handles interceptor ordering, inheritance, and independently compiled modules.

### Source excerpt

I recently posted on the Cash Code Blog announcing Burst's new test interceptors feature. They are similar to JUnit rules in API and capability. A Small API A typical use case is connecting some lifecycle to a test's execution. Perhaps we want a chess engine to be available

## Write Clean Classes Like a PRO

DevFeed: [Write Clean Classes Like a PRO](<https://devfeed.tech/articles/write-clean-classes-like-a-pro-26216.md>)

Original publisher: [Read original article](<https://craftbettersoftware.com/p/write-clean-classes-like-a-pro>)

Author: Daniel Moka

Published: 2025-04-19T05:00:55Z

Content type: article

Language: en

Sources: [Craft Better Software](<https://devfeed.tech/sources/craft-better-software.md>)

Topics: [clean-code](<https://devfeed.tech/topics/clean-code.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [software-development](<https://devfeed.tech/topics/software-development.md>), [programming-tips](<https://devfeed.tech/topics/programming-tips.md>), [object](<https://devfeed.tech/topics/object.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [classes](<https://devfeed.tech/tags/classes.md>), [clean-code](<https://devfeed.tech/tags/clean-code.md>), [composition](<https://devfeed.tech/tags/composition.md>), [composition-over-inheritance](<https://devfeed.tech/tags/composition-over-inheritance.md>), [data-transfer-objects](<https://devfeed.tech/tags/data-transfer-objects.md>), [fields](<https://devfeed.tech/tags/fields.md>), [flow](<https://devfeed.tech/tags/flow.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [responsibility](<https://devfeed.tech/tags/responsibility.md>)

### AI overview

The excerpt recommends making classes easier to understand and change by using noun-based names, hiding state behind intention-revealing behavior (with DTOs as an exception), and keeping a class's public API focused. It also suggests ordering methods by call flow so readers can follow the logic. The excerpt begins a recommendation to favor composition over inheritance but cuts off before explaining it, and it introduces six principles without showing them all.

### Source excerpt

7 essential tips to produce maintainable and intention-revealing classes

## Class Pollution in Ruby: A Deep Dive into Exploiting Recursive Merges

DevFeed: [Class Pollution in Ruby: A Deep Dive into Exploiting Recursive Merges](<https://devfeed.tech/articles/class-pollution-in-ruby-a-deep-dive-into-exploiting-recursive-merges-92053.md>)

Original publisher: [Read original article](<https://blog.doyensec.com/2024/10/02/class-pollution-ruby.html>)

Published: 2024-10-01T22:00:00Z

Content type: article

Language: en

Sources: [Doyensec](<https://devfeed.tech/sources/doyensec.md>)

Topics: [Ruby](<https://devfeed.tech/topics/ruby.md>), [class](<https://devfeed.tech/topics/class.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [superclass](<https://devfeed.tech/topics/superclass.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>)

Tags: [about](<https://devfeed.tech/tags/about.md>), [admin](<https://devfeed.tech/tags/admin.md>), [allows](<https://devfeed.tech/tags/allows.md>), [alter](<https://devfeed.tech/tags/alter.md>), [application](<https://devfeed.tech/tags/application.md>), [auditing](<https://devfeed.tech/tags/auditing.md>), [automation](<https://devfeed.tech/tags/automation.md>), [base](<https://devfeed.tech/tags/base.md>), [based](<https://devfeed.tech/tags/based.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [behaviors](<https://devfeed.tech/tags/behaviors.md>), [blog](<https://devfeed.tech/tags/blog.md>), [blog-post](<https://devfeed.tech/tags/blog-post.md>), [can](<https://devfeed.tech/tags/can.md>), [cases](<https://devfeed.tech/tags/cases.md>), [class](<https://devfeed.tech/tags/class.md>), [classes](<https://devfeed.tech/tags/classes.md>), [deep](<https://devfeed.tech/tags/deep.md>), [deep-dive](<https://devfeed.tech/tags/deep-dive.md>), [dive](<https://devfeed.tech/tags/dive.md>), [doyensec](<https://devfeed.tech/tags/doyensec.md>), [doyensecurity](<https://devfeed.tech/tags/doyensecurity.md>), [exploit](<https://devfeed.tech/tags/exploit.md>), [hacking](<https://devfeed.tech/tags/hacking.md>), [infosec](<https://devfeed.tech/tags/infosec.md>), [offensive](<https://devfeed.tech/tags/offensive.md>), [pentest](<https://devfeed.tech/tags/pentest.md>), [pentester](<https://devfeed.tech/tags/pentester.md>), [pollution](<https://devfeed.tech/tags/pollution.md>), [reverse-engineering](<https://devfeed.tech/tags/reverse-engineering.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [security](<https://devfeed.tech/tags/security.md>), [vulnerability](<https://devfeed.tech/tags/vulnerability.md>)

### AI overview

Recursive merges that assign data to Ruby object attributes can alter behavior beyond the supplied values, and recursive traversal can escape an object to affect parent or unrelated classes. The article distinguishes hash-only merges, which it says cannot pollute classes, from nonrecursive attribute merges, which affect one object, and recursive attribute merges, which can have broader effects. Its example shows instance-level method injection enabling privilege escalation or code execution when protected methods are evaluated. ActiveSupport's `deep_merge` works on hashes and becomes risky in the article's example when merged values are then assigned as object attributes. Hashie merges object attributes and blocks direct method replacement, but the article describes an exception involving the `_` attribute that can bypass an authorization check. Further examples demonstrate poisoning a parent class variable to redirect HTTP requests and repeatedly targeting subclasses to alter a signing key; the latter is random and may over-infect classes. The article concludes that recursive merges of untrusted data can compromise application behavior across requests.

### Source excerpt

Introduction In this post, we are going to explore a rarely discussed class of vulnerabilities in Ruby, known as class pollution. This concept is inspired by the idea of prototype pollution in JavaScript, where recursive merges are exploited to poison the prototype of objects, leading to unexpected behaviors. This idea was initially discussed in a blog post about prototype pollution in Python, in which the researcher used recursive merging to poison class variables and eventually global variables via the __globals__ attribute. In Ruby, we can categorize class pollution into three main cases: Merge on Hashes: In this scenario, class pollution isn't possible because the merge operation is confined to the hash itself. Merge on Attributes (Non-Recursive): Here, we can poison the instance variables of an object, potentially replacing methods by injecting return values. This pollution is limited to the object itself and does not affect the class. current_obj.instance_variable_set("@#{key}", new_object) current_obj.singleton_class.attr_accessor key Merge on Attributes (Recursive): In this case, the recursive nature of the merge allows us to escape the object context and poison attributes or methods of parent classes or even unrelated classes, leading to a broader impact on the application. Merge on Attributes Let's start by examining a code example where we exploit a recursive merge to modify object methods and alter the application's behavior. This type of pollution is limited to the object itself. require 'json' # Base class for both Admin and Regular users class Person attr_accessor :name, :age, :details def initialize(name:, age:, details:) @name = name @age = age @details = details end # Method to merge additional data into the object def merge_with(additional) recursive_merge(self, additional) end # Authorize based on the `to_s` method result def authorize if to_s == "Admin" puts "Access granted: #{@name} is an admin." else puts "Access denied: #{@name} is not an adm

## Extend or implement

DevFeed: [Extend or implement](<https://devfeed.tech/articles/extend-or-implement-44123.md>)

Original publisher: [Read original article](<https://stitcher.io/blog/extends-vs-implements>)

Author: Brent

Published: 2024-08-21T00:00:00Z

Content type: opinion

Language: en

Sources: [Stitcher](<https://devfeed.tech/sources/stitcher-io.md>)

Topics: [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [abstract class](<https://devfeed.tech/topics/abstract-class.md>), [interface](<https://devfeed.tech/topics/interface.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>), [Laravel](<https://devfeed.tech/topics/laravel.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Symfony](<https://devfeed.tech/topics/symfony.md>)

Tags: [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [class](<https://devfeed.tech/tags/class.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [interface](<https://devfeed.tech/tags/interface.md>), [laravel](<https://devfeed.tech/tags/laravel.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [oop](<https://devfeed.tech/tags/oop.md>), [symfony](<https://devfeed.tech/tags/symfony.md>)

### AI overview

A personal essay examines the difference between extending an abstract class and implementing an interface, arguing that inheritance is often used to provide configuration and flexibility in ways that do not fit its intended role in object-oriented programming. It discusses examples from Laravel, Symfony, and C++ and reflects on Alan Kay's critique of how OOP evolved.

### Source excerpt

Read the full post on https://stitcher.io/blog/extends-vs-implements

## Data Classes and Destructuring

DevFeed: [Data Classes and Destructuring](<https://devfeed.tech/articles/data-classes-and-destructuring-25052.md>)

Original publisher: [Read original article](<https://typealias.com/start/kotlin-data-classes-and-destructuring/>)

Author: author@typealias.com (Dave Leeds)

Published: 2023-10-09T00:00:00Z

Content type: article

Language: en

Sources: [Dave Leeds on Kotlin - typealias.com](<https://devfeed.tech/sources/dave-leeds-on-kotlin-typealias-com.md>)

Topics: [class](<https://devfeed.tech/topics/class.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>)

Tags: [class](<https://devfeed.tech/tags/class.md>), [classes](<https://devfeed.tech/tags/classes.md>), [copy](<https://devfeed.tech/tags/copy.md>), [data](<https://devfeed.tech/tags/data.md>), [data-class](<https://devfeed.tech/tags/data-class.md>), [destructuring](<https://devfeed.tech/tags/destructuring.md>), [destructuring-assignment](<https://devfeed.tech/tags/destructuring-assignment.md>), [equals](<https://devfeed.tech/tags/equals.md>), [functions](<https://devfeed.tech/tags/functions.md>), [hashcode](<https://devfeed.tech/tags/hashcode.md>), [introduction](<https://devfeed.tech/tags/introduction.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [learn-to-program](<https://devfeed.tech/tags/learn-to-program.md>), [object](<https://devfeed.tech/tags/object.md>), [open](<https://devfeed.tech/tags/open.md>), [open-class](<https://devfeed.tech/tags/open-class.md>), [operator](<https://devfeed.tech/tags/operator.md>), [override](<https://devfeed.tech/tags/override.md>), [programming](<https://devfeed.tech/tags/programming.md>), [properties](<https://devfeed.tech/tags/properties.md>), [reference](<https://devfeed.tech/tags/reference.md>), [tostring](<https://devfeed.tech/tags/tostring.md>)

### AI overview

The excerpt introduces Kotlin data classes as useful for immutable classes that mainly hold properties, then begins with the distinction between objects that share a name and the exact instance being checked. It sets up two separate `Fiona` objects to explain reference equality using Kotlin's equality operator (`==`). The excerpt does not show the promised discussion of overriding `equals()`, `hashCode()`, or `toString()`, nor destructuring.

### Source excerpt

At the end of the last chapter, we saw how all objects in Kotlin inherit three functions from an open class called Any. Those functions are equals(), hashCode(), and toString(). In this chapter, we're going to learn about data classes, which are super-powered classes that are especially helpful when we've got an immutable class that mainly just holds properties. To better understand data classes, let's first explore each of the three functions above, and see what's involved when we override them!

## Sealed classes and interfaces in Kotlin

DevFeed: [Sealed classes and interfaces in Kotlin](<https://devfeed.tech/articles/sealed-classes-and-interfaces-in-kotlin-39339.md>)

Original publisher: [Read original article](<https://kt.academy/article/kfde-sealed>)

Published: 2023-09-04T00:01:00Z

Content type: tutorial

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [sealed class](<https://devfeed.tech/topics/sealed-class.md>), [sealed interface](<https://devfeed.tech/topics/sealed-interface.md>), [interface](<https://devfeed.tech/topics/interface.md>), [abstract class](<https://devfeed.tech/topics/abstract-class.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>)

Tags: [inheritance](<https://devfeed.tech/tags/inheritance.md>), [interface](<https://devfeed.tech/tags/interface.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [polymorphism](<https://devfeed.tech/tags/polymorphism.md>), [sealed](<https://devfeed.tech/tags/sealed.md>), [sealed-classes](<https://devfeed.tech/tags/sealed-classes.md>), [sealed-interface](<https://devfeed.tech/tags/sealed-interface.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This Kotlin tutorial explains sealed classes and sealed interfaces as restricted hierarchies whose direct subclasses are controlled. It contrasts them with regular interfaces and abstract classes, describes their package and module requirements, and explains their use in exhaustive expressions.

### Source excerpt

What are sealed classes and interfaces in Kotlin and how do we use them.

## The Future of Programming: AI and Interface-Oriented Languages

DevFeed: [The Future of Programming: AI and Interface-Oriented Languages](<https://devfeed.tech/articles/the-future-of-programming-ai-and-interface-oriented-languages-20718.md>)

Original publisher: [Read original article](<https://medium.com/javascript-scene/the-future-of-programming-ai-and-interface-oriented-languages-119f155466ef?source=rss----c0aeac5284ad---4>)

Author: Eric Elliott

Published: 2023-07-24T18:59:09Z

Content type: article

Language: en

Sources: [Eric Elliot](<https://devfeed.tech/sources/eric-elliot.md>)

Topics: [sudolang](<https://devfeed.tech/topics/sudolang.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [interface](<https://devfeed.tech/topics/interface.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Claude](<https://devfeed.tech/topics/claude.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-code](<https://devfeed.tech/tags/ai-code.md>), [chatgpt](<https://devfeed.tech/tags/chatgpt.md>), [code](<https://devfeed.tech/tags/code.md>), [future](<https://devfeed.tech/tags/future.md>), [interface](<https://devfeed.tech/tags/interface.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [languages](<https://devfeed.tech/tags/languages.md>), [natural-language](<https://devfeed.tech/tags/natural-language.md>), [programming](<https://devfeed.tech/tags/programming.md>), [software](<https://devfeed.tech/tags/software.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [technology](<https://devfeed.tech/tags/technology.md>)

### AI overview

SudoLang is presented as a language for structuring programs to work with AI models: interfaces bundle state, natural-language constraints, and commands, while composition combines smaller interfaces into larger program state. The HelloCounter example shows a constraint keeping its count at 10 when asked to increment 12 times. The text says SudoLang programs can be transpiled to JavaScript, Python, Rust, or C. It reports that ChatGPT 3.5 and Claude 2 handle the example, while Bard fails to respect constraints and LLaMA 2 struggles; GPT-4 is recommended for complex programs. SudoLang favors composition over class inheritance and omits class-related keywords and explicit constructors. For data protection, the article stresses defining access and manipulation constraints, while warning that models may be manipulated and even GPT-4-level enforcement is not bullet-proof.

### Source excerpt

AI language models, such as ChatGPT and Claude, empower anyone to create software. These models can intelligently understand problems, create solutions, and explain the solutions. But natural language isn't always the best way to communicate with AI. If you need to keep track of complex data and define how you interact with that data in specific ways, SudoLang can help. If you think this is only going to help with AI code, think again. You can author any program in SudoLang and then transpile it to other languages, like JavaScript, Python, Rust, or C -- so you can take advantage of these features no matter what kind of software you're building. What is SudoLang? SudoLang is a programming language designed to collaborate with AI language models including ChatGPT, Bing Chat, Anthropic Claude, and Google Bard. It is designed to be easy to learn and use. It is also very expressive and powerful. All advanced language models understand it without any special prompting. You do not need to paste the SudoLang specification before using SudoLang with your favorite AI. Please read the SudoLang documentation for more information about the language. Interfaces in SudoLang Interface-oriented programming lets you structure your program and easily declare what you want the AI to keep track of and how you want to interact with it. Interfaces are a powerful tool to encapsulate related state, constraints, commands, and functions. They organize the code in a clear, understandable, and reusable way. The key features of interfaces in SudoLang include: State: This represents the data associated with the interface. Constraints: These are rules or requirements defined in natural language that the AI maintains automatically. /Commands and methods: These are operations that can be performed on or by the interface. Here's a simple example: HelloCounter { message: "Hello, World!" count: 0 Constraints { count <= 10 } /increment - Increment count by 1. /say hello - Display the message. } HelloCoun

## New Features for Qute Templating Engine Support in Quarkus Tools for Visual Studio Code 1.13.0

DevFeed: [New Features for Qute Templating Engine Support in Quarkus Tools for Visual Studio Code 1.13.0](<https://devfeed.tech/articles/new-features-for-qute-templating-engine-support-in-quarkus-tools-for-visual-studio-code-1-13-0-43974.md>)

Original publisher: [Read original article](<https://quarkus.io/blog/vscode-quarkus-1-13-0-released/>)

Author: Jessica He (https://twitter.com/JessicaJjhe)

Published: 2023-04-19T00:00:00Z

Content type: release

Language: en

Sources: [Quarkus - Supersonic Subatomic Java](<https://devfeed.tech/sources/quarkus-supersonic-subatomic-java.md>)

Topics: [Quarkus](<https://devfeed.tech/topics/quarkus.md>), [Visual Studio Code](<https://devfeed.tech/topics/visual-studio-code.md>), [Template](<https://devfeed.tech/topics/template.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [reusable code](<https://devfeed.tech/topics/reusable-code.md>), [Snippet](<https://devfeed.tech/topics/snippet.md>), [syntax](<https://devfeed.tech/topics/syntax.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [new-features](<https://devfeed.tech/tags/new-features.md>), [quarkus](<https://devfeed.tech/tags/quarkus.md>), [release](<https://devfeed.tech/tags/release.md>), [snippet](<https://devfeed.tech/tags/snippet.md>), [syntax](<https://devfeed.tech/tags/syntax.md>), [template](<https://devfeed.tech/tags/template.md>), [templating](<https://devfeed.tech/tags/templating.md>), [tools](<https://devfeed.tech/tags/tools.md>), [visual-studio-code](<https://devfeed.tech/tags/visual-studio-code.md>)

### AI overview

Quarkus Tools for Visual Studio Code 1.13.0 adds Qute templating support, including improved validation, document links, completion, code lens, fragment support, and smarter user-tag snippets.

### Source excerpt

Quarkus Tools for Visual Studio Code 1.13.0 has been released on the VS Code Marketplace and Open VSX. This release focuses on Qute Templating Engine Support by introducing support for more sections and improving template validation. New Features Notable Qute features included in Quarkus Tools for Visual Studio Code 1.13.0 include: #include and #insert Section Support #fragment Section support User Tag Support Improvement Validation for All Opened and Unopened Qute Templates New Qute Syntax Validator Surround with Command Renarde Support For a list of all changes, please refer to the changelog. #include and #insert Section Support Improvement The #include section can be used to specify the extended template to include in the current template. Using #include and #insert sections together enables template inheritance, which allows the reuse of template layouts. See #include section usage for more information. This release extends the support for these sections with validation, document link, completion, and code lens. Validation ensures the inserted template exists and the contents are defined in the extended template. Document link provides easy access to the inserted template by performing a ctrl-click to follow the link. Completion suggests any available templates to insert. It will also suggest expected content from the extended template when completion is triggered within a #include section. Code lens was added to #insert sections to easily navigate to all instances where it is used. #fragment Section Support Fragment sections define a part of the template that can be treated and rendered as a separate template. In this release, we introduced support for this section including snippet completion, hover, validation, and syntax coloration. Support with Quarkus integration includes code lens and document link to access the referenced #fragment section from the template instance in Java. User Tag Support Improvement User-defined Tags are used to define a tag template

## Introduction to Class Delegation

DevFeed: [Introduction to Class Delegation](<https://devfeed.tech/articles/introduction-to-class-delegation-25053.md>)

Original publisher: [Read original article](<https://typealias.com/start/kotlin-delegation/>)

Author: author@typealias.com (Dave Leeds)

Published: 2023-02-06T00:00:00Z

Content type: article

Language: en

Sources: [Dave Leeds on Kotlin - typealias.com](<https://devfeed.tech/sources/dave-leeds-on-kotlin-typealias-com.md>)

Topics: [Inheritance](<https://devfeed.tech/topics/inheritance.md>), [class](<https://devfeed.tech/topics/class.md>), [interface](<https://devfeed.tech/topics/interface.md>)

Tags: [delegation](<https://devfeed.tech/tags/delegation.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [introduction](<https://devfeed.tech/tags/introduction.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [learn-to-program](<https://devfeed.tech/tags/learn-to-program.md>), [override](<https://devfeed.tech/tags/override.md>), [programming](<https://devfeed.tech/tags/programming.md>)

### AI overview

Kotlin class delegation lets an object reuse functions and properties through interfaces by handing requests to another object when needed. The excerpt illustrates the pattern with a waiter: the waiter handles a soda order directly, but passes entrée preparation to the chef and delivers the result to the customer. The customer interacts only with the waiter, who acts on their behalf. The excerpt introduces this idea and manual delegation, but ends before showing the Kotlin implementation.

### Source excerpt

Back in Chapter 2, we introduced functions as a way to prevent us from duplicating expressions. Once we start working with classes, we might notice that it's also possible to end up duplicating our functions. There are lots of ways to reuse our functions instead of duplicating them. In this chapter, we'll see how we can use interfaces with Kotlin's class delegation feature to reuse the code from our functions and properties.

## Readonly classes in PHP 8.2

DevFeed: [Readonly classes in PHP 8.2](<https://devfeed.tech/articles/readonly-classes-in-php-8-2-44257.md>)

Original publisher: [Read original article](<https://stitcher.io/blog/readonly-classes-in-php-82>)

Author: Brent

Published: 2022-10-25T00:00:00Z

Content type: tutorial

Language: en

Sources: [Stitcher](<https://devfeed.tech/sources/stitcher-io.md>)

Topics: [PHP](<https://devfeed.tech/topics/php.md>), [class](<https://devfeed.tech/topics/class.md>), [properties](<https://devfeed.tech/topics/properties.md>), [constructor](<https://devfeed.tech/topics/constructor.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>)

Tags: [classes](<https://devfeed.tech/tags/classes.md>), [constructor](<https://devfeed.tech/tags/constructor.md>), [deprecated](<https://devfeed.tech/tags/deprecated.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [php](<https://devfeed.tech/tags/php.md>), [properties](<https://devfeed.tech/tags/properties.md>)

### AI overview

An explanation of readonly classes introduced in PHP 8.2. It describes how they make all class properties readonly and reviews the rules governing writes, typing, static properties, default values, inheritance, dynamic properties, and reflection.

### Source excerpt

Read the full post on https://stitcher.io/blog/readonly-classes-in-php-82

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