# object oriented

Published articles for object oriented.

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

## Introduction to Object-Oriented Programming in Python

DevFeed: [Introduction to Object-Oriented Programming in Python](<https://devfeed.tech/articles/introduction-to-object-oriented-programming-in-python-38810.md>)

Original publisher: [Read original article](<https://thepalindrome.org/p/introduction-to-object-oriented-programming>)

Author: Stephen Gruppetta

Published: 2026-05-08T12:29:01Z

Content type: tutorial

Language: en

Sources: [The Palindrome](<https://devfeed.tech/sources/the-palindrome.md>)

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

Tags: [introduction](<https://devfeed.tech/tags/introduction.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [programming](<https://devfeed.tech/tags/programming.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

An introduction to object-oriented programming in Python. The supplied evidence does not provide further substantive details.

### Source excerpt

The true way of doing stuff with data

## 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>), [interfaces](<https://devfeed.tech/topics/interfaces.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

## A critical history of JavaScript's prototype-based design and later TypeScript and ES6 changes

DevFeed: [A critical history of JavaScript's prototype-based design and later TypeScript and ES6 changes](<https://devfeed.tech/articles/the-fall-of-javascript-35600.md>)

Original publisher: [Read original article](<https://www.yegor256.com/2025/12/28/fall-of-javascript.html>)

Author: Yegor Bugayenko (yegor256@gmail.com)

Published: 2025-12-27T21:00:00Z

Content type: opinion

Language: en

Sources: [Yegor Bugayenko](<https://devfeed.tech/sources/yegor-bugayenko.md>)

Topics: [JavaScript](<https://devfeed.tech/topics/javascript.md>), [TypeScript](<https://devfeed.tech/topics/typescript.md>), [es6](<https://devfeed.tech/topics/es6.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [es6](<https://devfeed.tech/tags/es6.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [oop](<https://devfeed.tech/tags/oop.md>), [prototype](<https://devfeed.tech/tags/prototype.md>), [prototypes](<https://devfeed.tech/tags/prototypes.md>), [typescript](<https://devfeed.tech/tags/typescript.md>), [typescript-is-clumsy](<https://devfeed.tech/tags/typescript-is-clumsy.md>), [typescript-is-ugly](<https://devfeed.tech/tags/typescript-is-ugly.md>), [typescript-types](<https://devfeed.tech/tags/typescript-types.md>), [typescript-vs-javascript](<https://devfeed.tech/tags/typescript-vs-javascript.md>)

### AI overview

This opinion article recounts JavaScript's origins and argues that its prototype-based, class-free design was later undermined by TypeScript and ES6 classes. It also compares JavaScript's object model with Scheme, Self, C++, and Java.

### Source excerpt

JavaScript was an elegant prototype-based class-free language until TypeScript and ES6 classes ruined it.

## Abstraction design: Introduction

DevFeed: [Abstraction design: Introduction](<https://devfeed.tech/articles/abstraction-design-introduction-39268.md>)

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

Published: 2024-02-05T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [abstraction](<https://devfeed.tech/topics/abstraction.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [interfaces](<https://devfeed.tech/topics/interfaces.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>)

Tags: [abstraction](<https://devfeed.tech/tags/abstraction.md>), [concepts](<https://devfeed.tech/tags/concepts.md>), [core](<https://devfeed.tech/tags/core.md>), [function](<https://devfeed.tech/tags/function.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [programming](<https://devfeed.tech/tags/programming.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This introduction explains abstraction as a form of simplification that hides complexity by deciding what to expose and what to conceal. It discusses abstractions in object-oriented and functional programming, including interfaces, classes, functions, and higher-level operations, with examples involving Java and Kotlin.

### Source excerpt

What is abstraction in programming and why is it so important.

## Workflows as Actors: Is it really possible?

DevFeed: [Workflows as Actors: Is it really possible?](<https://devfeed.tech/articles/workflows-as-actors-is-it-really-possible-36118.md>)

Original publisher: [Read original article](<https://temporal.io/blog/workflows-as-actors-is-it-really-possible>)

Author: Fitz

Published: 2023-06-27T22:00:00Z

Content type: tutorial

Language: en

Sources: [Temporal Blog](<https://devfeed.tech/sources/temporal-blog.md>)

Topics: [Actor](<https://devfeed.tech/topics/actor.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [Complex Systems](<https://devfeed.tech/topics/complex-systems.md>)

Tags: [actor](<https://devfeed.tech/tags/actor.md>), [blog-post](<https://devfeed.tech/tags/blog-post.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [design-patterns](<https://devfeed.tech/tags/design-patterns.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [temporal-concepts](<https://devfeed.tech/tags/temporal-concepts.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

This article introduces the Actor Model and compares actors with objects, focusing on message passing, state, actor creation, and encapsulation. It then explains how Temporal Workflows can be built to behave like actors.

### Source excerpt

An overview on how to use Temporal Workflows in the form of an Actor Model

## Four of a Kotlin Kind at I code Java 2022 conference

DevFeed: [Four of a Kotlin Kind at I code Java 2022 conference](<https://devfeed.tech/articles/four-of-a-kotlin-kind-at-i-code-java-2022-conference-32052.md>)

Original publisher: [Read original article](<https://www.maiatoday.net/p/four-of-a-kotlin-kind-at-i-code-java-2022-conference/>)

Published: 2022-10-14T08:30:41Z

Content type: article

Language: en

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

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Code](<https://devfeed.tech/topics/code.md>), [Software](<https://devfeed.tech/topics/software.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [concepts](<https://devfeed.tech/tags/concepts.md>), [conference](<https://devfeed.tech/tags/conference.md>), [declarative](<https://devfeed.tech/tags/declarative.md>), [functional](<https://devfeed.tech/tags/functional.md>), [imperative](<https://devfeed.tech/tags/imperative.md>), [java](<https://devfeed.tech/tags/java.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [pitfalls](<https://devfeed.tech/tags/pitfalls.md>), [talk](<https://devfeed.tech/tags/talk.md>), [tips](<https://devfeed.tech/tags/tips.md>), [traces](<https://devfeed.tech/tags/traces.md>)

### AI overview

The article introduces a talk about Kotlin's support for imperative, declarative, functional, and object-oriented programming. It highlights tips, guidelines, pitfalls, definitions, software history, and how Kotlin supports these concepts.

### Source excerpt

I shared my talk titled Imperative, Declarative, Object oriented, functional: Four of a Kotlin Kind at the I code Java conference. The abstract: Is Kotlin a functional language? Yes, but... Is it object oriented? Yes, but... Looking at four concepts: imperative, declarative, functional and object oriented How does Kotlin make it easy to use either or all at the same time. This talk contains: Some useful Kotlin tips, some guidelines and pitfalls for the four concepts, traces of definitions and software history. After listening to this talk you will understand what these concepts are, what each is good for and how they are supported by the Kotlin language. You can see the talk here

## Object-oriented or functional? Two ways to see the world

DevFeed: [Object-oriented or functional? Two ways to see the world](<https://devfeed.tech/articles/object-oriented-or-functional-two-ways-to-see-the-world-39357.md>)

Original publisher: [Read original article](<https://kt.academy/article/oop-vs-fp>)

Published: 2022-08-18T00:00:00Z

Content type: opinion

Language: en

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

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

Tags: [fp](<https://devfeed.tech/tags/fp.md>), [functional](<https://devfeed.tech/tags/functional.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [oop](<https://devfeed.tech/tags/oop.md>), [polymorphism](<https://devfeed.tech/tags/polymorphism.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This opinion article compares object-oriented programming and functional programming as ways of thinking about program design, rather than merely collections of features. It uses different ways of viewing a bedroom--as objects or actions--to illustrate the distinction while acknowledging that modern languages commonly support both styles.

### Source excerpt

The difference between the OOP and FP paradigms is deeply rooted in how we see the world. A few words on the philosophy of both approaches.

## Unspoken Assumptions Underlying OO Design Maxims

DevFeed: [Unspoken Assumptions Underlying OO Design Maxims](<https://devfeed.tech/articles/unspoken-assumptions-underlying-oo-design-maxims-32238.md>)

Original publisher: [Read original article](<https://bruceeckel.com/blog/2019-12-24-unspoken-assumptions-underlying-oo-design-maxims/>)

Author: Bruce Eckel

Published: 2019-12-24T00:00:00Z

Content type: opinion

Language: en

Sources: [Bruce Eckel - Computing Thoughts](<https://devfeed.tech/sources/bruce-eckel-computing-thoughts.md>)

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

Tags: [approach](<https://devfeed.tech/tags/approach.md>), [change](<https://devfeed.tech/tags/change.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [oop](<https://devfeed.tech/tags/oop.md>)

### AI overview

The article argues that many object-oriented design maxims implicitly assume developers can predict how a system will change. It questions whether adding complexity to support uncertain future changes is justified, using the open-closed principle and polymorphism as examples.

### Source excerpt

For Atomic Kotlin, I've been struggling with an "atom" (very small chapter) during the last couple of months. It's on object-oriented design, and it brought up a lot of feelings I've had for quite awhile about some of the various maxims and design guidelines that have appeared in recent decades, since OO became mainstream. I couldn't quite put my finger on what bothered me about these design ideas. Then @codingunicorn did it for me by writing a post called Flexible code considered harmful.

## Object Relational Database Management System

DevFeed: [Object Relational Database Management System](<https://devfeed.tech/articles/object-relational-database-management-system-34586.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2018/03/object-relational-database-management-system/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2018-03-22T16:40:39Z

Content type: article

Language: en

Sources: [Dimitri Fontaine](<https://devfeed.tech/sources/dimitri-fontaine.md>)

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Database](<https://devfeed.tech/topics/database.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>)

Tags: [database](<https://devfeed.tech/tags/database.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [ordbms](<https://devfeed.tech/tags/ordbms.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [programming](<https://devfeed.tech/tags/programming.md>)

### AI overview

This article explains why PostgreSQL is described as an object-relational database management system. It introduces object-oriented programming and discusses object-orientation models, including message passing, in relation to database systems and programming languages.

### Source excerpt

PostgreSQL is the world's most advanced open source database, and per the PostgreSQL Wikipedia page it is an object-relational database management system (ORDBMS) with an emphasis on extensibility and standards compliance. In this article, we try to understand why would PostgreSQL be named an object-relational thing. What is Object Oriented Programming and how does that apply to a database system?

## Functional vs Object-oriented approaches to validation

DevFeed: [Functional vs Object-oriented approaches to validation](<https://devfeed.tech/articles/functional-vs-object-oriented-approaches-to-validation-32148.md>)

Original publisher: [Read original article](<https://adambard.com/blog/oo-vs-functional-form-validation/>)

Published: 2014-12-07T00:00:00Z

Content type: tutorial

Language: en

Sources: [Adam Bard](<https://devfeed.tech/sources/adam-bard.md>)

Topics: [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Python](<https://devfeed.tech/topics/python.md>), [Exception](<https://devfeed.tech/topics/exception.md>)

Tags: [exception](<https://devfeed.tech/tags/exception.md>), [functional](<https://devfeed.tech/tags/functional.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [python](<https://devfeed.tech/tags/python.md>), [validation](<https://devfeed.tech/tags/validation.md>)

### AI overview

This article compares functional and object-oriented approaches to validating and cleaning data in Python. It presents equivalent validation designs that return cleaned data on success and collect errors when validation fails, while discussing closures, exceptions, and execution flow.

### Source excerpt

Functional programming is often described in terms of its contrast with object-oriented programs; that is, you write functions that act on data instead of objects that wrap data and use methods to act on themselves. Functional programming wonks (like me) will tell you that writing code this way is generally better than OO, but I don't want to do that (right now). However, in this post, I'm not here to argue either side. Today, I'm just going to demonstrate a few equivalent approaches to the same problem: validating data.

## Clojure is not for geniuses

DevFeed: [Clojure is not for geniuses](<https://devfeed.tech/articles/clojure-is-not-for-geniuses-32105.md>)

Original publisher: [Read original article](<https://adambard.com/blog/clojure-is-not-for-geniuses/>)

Published: 2014-11-18T00:00:00Z

Content type: opinion

Language: en

Sources: [Adam Bard](<https://devfeed.tech/sources/adam-bard.md>)

Topics: [ClojureScript](<https://devfeed.tech/topics/clojurescript.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Software](<https://devfeed.tech/topics/software.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [assembly](<https://devfeed.tech/tags/assembly.md>), [blog](<https://devfeed.tech/tags/blog.md>), [c](<https://devfeed.tech/tags/c.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [functional](<https://devfeed.tech/tags/functional.md>), [language](<https://devfeed.tech/tags/language.md>), [languages](<https://devfeed.tech/tags/languages.md>), [memory](<https://devfeed.tech/tags/memory.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [objective-c](<https://devfeed.tech/tags/objective-c.md>), [programming](<https://devfeed.tech/tags/programming.md>), [software](<https://devfeed.tech/tags/software.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

The article argues that Clojure is not limited to genius programmers. It presents immutable collection semantics and reduced program and library complexity as ways to reduce the mental effort required to understand and debug software, contrasting this with the lifecycle-tracing demands of mutable object-oriented systems.

### Source excerpt

It's a common attitude that functional languages with immutable collection semantics, such as Clojure, are for a) pretentious language geeks, or b) actual genius programmers. I'm in no position to defend against point a) given the body of my writing on this blog, so today I'd like to write an article about point b).

## Java to Clojure: "Refactoring" refactored functionally

DevFeed: [Java to Clojure: "Refactoring" refactored functionally](<https://devfeed.tech/articles/java-to-clojure-refactoring-refactored-functionally-32156.md>)

Original publisher: [Read original article](<https://adambard.com/blog/refactoring-refactored/>)

Published: 2014-06-10T00:00:00Z

Content type: tutorial

Language: en

Sources: [Adam Bard](<https://devfeed.tech/sources/adam-bard.md>)

Topics: [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Clojure](<https://devfeed.tech/topics/clojure.md>), [Java](<https://devfeed.tech/topics/java.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [clojure](<https://devfeed.tech/tags/clojure.md>), [code](<https://devfeed.tech/tags/code.md>), [functional](<https://devfeed.tech/tags/functional.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [java](<https://devfeed.tech/tags/java.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [types](<https://devfeed.tech/tags/types.md>)

### AI overview

This tutorial refactors a video-store example from object-oriented Java into a more functional Clojure style. It compares the original class-based design with Clojure protocols and immutable records, while noting that the source example differs from Martin Fowler's book.

### Source excerpt

I was searching for a good example to illustrate some properties of refactoring object-oriented code into a more functional style, and I came across this example from Martin Fowler's Refactoring. It describes the process of refactoring code for a video store. It's a nice little example with a useful narrative to go along with it.

## Monstera: An Experiment in Using C++ and Object-Oriented Design for ReactOS's Memory Manager

DevFeed: [Monstera: An Experiment in Using C++ and Object-Oriented Design for ReactOS's Memory Manager](<https://devfeed.tech/articles/monstera-32866.md>)

Original publisher: [Read original article](<https://reactos.org/blogs/monstera/>)

Published: 2014-01-05T00:00:00Z

Content type: article

Language: en

Sources: [Front Page on ReactOS Website](<https://devfeed.tech/sources/front-page-on-reactos-website.md>)

Topics: [Kernel](<https://devfeed.tech/topics/kernel.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [coding patterns](<https://devfeed.tech/topics/coding-patterns.md>), [Development](<https://devfeed.tech/topics/development.md>)

Tags: [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [coding-patterns](<https://devfeed.tech/tags/coding-patterns.md>), [experiment](<https://devfeed.tech/tags/experiment.md>), [free](<https://devfeed.tech/tags/free.md>), [hybrid](<https://devfeed.tech/tags/hybrid.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [os](<https://devfeed.tech/tags/os.md>), [procedural](<https://devfeed.tech/tags/procedural.md>), [react](<https://devfeed.tech/tags/react.md>), [reactos](<https://devfeed.tech/tags/reactos.md>), [win32](<https://devfeed.tech/tags/win32.md>), [winapi](<https://devfeed.tech/tags/winapi.md>)

### AI overview

Monstera is an experiment to assess whether C++ and selected object-oriented design principles can simplify development of ReactOS's predominantly procedural, C-centric memory manager. The post notes that kernel-code constraints limit which C++ features can be used, and that the experiment's success remains uncertain.

### Source excerpt

This post really should have been made months ago, but finding the time to write a full blown newsletter has been getting more and more scarce. That being said, I've decided for the short term to split things that would normally act as a single newsletter section into separate blog posts so I don't need to wait and gather things. There was a lot of speculation as to what Monstera was when Aleksey made his commit with some suggesting it is a repeat of his ARWINSS effort but targetted at the memory manager.

## An Unbiased Comparison of F# and Scala

DevFeed: [An Unbiased Comparison of F# and Scala](<https://devfeed.tech/articles/an-unbiased-comparison-of-f-and-scala-33402.md>)

Original publisher: [Read original article](<https://timkellogg.me/blog/2013/06/22/comparing-scala-to-fsharp>)

Published: 2013-06-22T00:00:00Z

Content type: comparison

Language: en

Sources: [Tim Kellogg](<https://devfeed.tech/sources/tim-kellogg.md>)

Topics: [F#](<https://devfeed.tech/topics/fsharp.md>), [Scala](<https://devfeed.tech/topics/scala.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [comparison](<https://devfeed.tech/tags/comparison.md>), [f-sharp](<https://devfeed.tech/tags/f-sharp.md>), [functional](<https://devfeed.tech/tags/functional.md>), [functional-programming](<https://devfeed.tech/tags/functional-programming.md>), [languages](<https://devfeed.tech/tags/languages.md>), [object](<https://devfeed.tech/tags/object.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [programming](<https://devfeed.tech/tags/programming.md>), [scala](<https://devfeed.tech/tags/scala.md>)

### AI overview

A developer compares F# and Scala from the perspective of a .NET developer who began working with Scala. The article argues that Scala is more approachable but less purely functional, while F# adheres more closely to functional programming principles. It also compares their object-oriented features, function definitions, currying, and partial function application.

### Source excerpt

Given my history as a .NET developer I learned Functional Programming via F#, but I just started a new job as a Scala developer. Naturally, I've been comparing the two languages and the quirks and nuances that make could make them enjoyable or problematic. To summarize quickly, I think Scala is more approachable but less "pure" than F#. Scala seems to have a diverse set of influences whereas F# tries to stick closely to proven Functional Programming basics.

## Things that make me dislike Java

DevFeed: [Things that make me dislike Java](<https://devfeed.tech/articles/things-that-make-me-dislike-java-37860.md>)

Original publisher: [Read original article](<https://carlosbecker.com/posts/things-that-make-me-dislike-java/>)

Author: Carlos Alexandro Becker

Published: 2012-12-15T00:00:00Z

Content type: opinion

Language: en

Sources: [Carlos Becker](<https://devfeed.tech/sources/carlos-becker.md>)

Topics: [Java](<https://devfeed.tech/topics/java.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [class](<https://devfeed.tech/topics/class.md>), [generics](<https://devfeed.tech/topics/generics.md>), [Inheritance](<https://devfeed.tech/topics/inheritance.md>)

Tags: [generics](<https://devfeed.tech/tags/generics.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [java](<https://devfeed.tech/tags/java.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>)

### AI overview

An opinion piece discussing aspects of Java that the author dislikes, especially its object-oriented model, primitive types, wrapper classes, generics, autoboxing, and null behavior. The author also acknowledges Java's community, specifications, and libraries.

### Source excerpt

So, I just compiled a little list of things that, I believe, make me dislike Java everyday a little more.

## Dependency Inversion Principle

DevFeed: [Dependency Inversion Principle](<https://devfeed.tech/articles/dependency-inversion-principle-40667.md>)

Original publisher: [Read original article](<https://radek.io/posts/dependency-inversion-principle/>)

Published: 2011-08-10T00:00:00Z

Content type: article

Language: en

Sources: [Radek Pazdera](<https://devfeed.tech/sources/radek-pazdera.md>)

Topics: [Dependency Inversion](<https://devfeed.tech/topics/dependency-inversion.md>), [abstraction](<https://devfeed.tech/topics/abstraction.md>), [interface](<https://devfeed.tech/topics/interface.md>), [object](<https://devfeed.tech/topics/object.md>), [modules](<https://devfeed.tech/topics/modules.md>), [Software](<https://devfeed.tech/topics/software.md>)

Tags: [abstraction](<https://devfeed.tech/tags/abstraction.md>), [dependency-inversion](<https://devfeed.tech/tags/dependency-inversion.md>), [dependency-inversion-principle](<https://devfeed.tech/tags/dependency-inversion-principle.md>), [interface](<https://devfeed.tech/tags/interface.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [software](<https://devfeed.tech/tags/software.md>), [solid](<https://devfeed.tech/tags/solid.md>)

### AI overview

The article explains the Dependency Inversion Principle, the D in SOLID, for object-oriented software design. It argues that high-level and low-level modules should depend on abstractions, while details should depend on those abstractions, improving module reuse and reducing direct coupling.

### Source excerpt

SOLID Object-Oriented Design

## Liskov Substitution Principle

DevFeed: [Liskov Substitution Principle](<https://devfeed.tech/articles/liskov-substitution-principle-40710.md>)

Original publisher: [Read original article](<https://radek.io/posts/liskov-substitution-principle/>)

Published: 2011-08-09T00:00:00Z

Content type: tutorial

Language: en

Sources: [Radek Pazdera](<https://devfeed.tech/sources/radek-pazdera.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [coding](<https://devfeed.tech/topics/coding.md>), [subclass](<https://devfeed.tech/topics/subclass.md>), [subtype](<https://devfeed.tech/topics/subtype.md>)

Tags: [hierarchy](<https://devfeed.tech/tags/hierarchy.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [software-design](<https://devfeed.tech/tags/software-design.md>), [solid](<https://devfeed.tech/tags/solid.md>), [subclass](<https://devfeed.tech/tags/subclass.md>), [subtype](<https://devfeed.tech/tags/subtype.md>)

### AI overview

This article explains the Liskov Substitution Principle, the L in SOLID object-oriented design. It presents definitions from Barbara Liskov and Jeannette Wing, a formulation by Robert C. Martin, and a Square-Rectangle hierarchy example showing how subtype behavior can violate substitutability.

### Source excerpt

SOLID Object-Oriented Design

## Single Responsibility Principle

DevFeed: [Single Responsibility Principle](<https://devfeed.tech/articles/single-responsibility-principle-40739.md>)

Original publisher: [Read original article](<https://radek.io/posts/single-responsibility-principle/>)

Published: 2011-08-08T00:00:00Z

Content type: tutorial

Language: en

Sources: [Radek Pazdera](<https://devfeed.tech/sources/radek-pazdera.md>)

Topics: [object](<https://devfeed.tech/topics/object.md>), [class](<https://devfeed.tech/topics/class.md>), [Code](<https://devfeed.tech/topics/code.md>), [Software](<https://devfeed.tech/topics/software.md>), [MySQL](<https://devfeed.tech/topics/mysql.md>)

Tags: [class](<https://devfeed.tech/tags/class.md>), [code](<https://devfeed.tech/tags/code.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [design](<https://devfeed.tech/tags/design.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [mysql](<https://devfeed.tech/tags/mysql.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [solid](<https://devfeed.tech/tags/solid.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

The article explains the Single Responsibility Principle (SRP), a SOLID guideline for object-oriented design. It defines a responsibility as a reason for a class to change and uses a MySQL connection and query-handling example to show why separate responsibilities should be split.

### Source excerpt

SOLID Object-Oriented Design

## SOLID Object-Oriented Design

DevFeed: [SOLID Object-Oriented Design](<https://devfeed.tech/articles/solid-object-oriented-design-40741.md>)

Original publisher: [Read original article](<https://radek.io/posts/solid-object-oriented-design/>)

Published: 2011-08-05T00:00:00Z

Content type: tutorial

Language: en

Sources: [Radek Pazdera](<https://devfeed.tech/sources/radek-pazdera.md>)

Topics: [object](<https://devfeed.tech/topics/object.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Software](<https://devfeed.tech/topics/software.md>), [interface](<https://devfeed.tech/topics/interface.md>), [Dependency Inversion](<https://devfeed.tech/topics/dependency-inversion.md>)

Tags: [dependency-inversion-principle](<https://devfeed.tech/tags/dependency-inversion-principle.md>), [interface](<https://devfeed.tech/tags/interface.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [solid](<https://devfeed.tech/tags/solid.md>)

### AI overview

The article introduces SOLID, an acronym for five principles of object-oriented programming and design: single responsibility, open/closed, Liskov substitution, interface segregation, and dependency inversion. It presents them as guidelines intended to support systems that are easier to maintain and extend over time.

### Source excerpt

I build software products and write on the Internet.

## Object Incest

DevFeed: [Object Incest](<https://devfeed.tech/articles/object-incest-33364.md>)

Original publisher: [Read original article](<https://timkellogg.me/blog/2011/03/23/object-incest>)

Published: 2011-03-23T00:00:00Z

Content type: tutorial

Language: en

Sources: [Tim Kellogg](<https://devfeed.tech/sources/tim-kellogg.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>), [interfaces](<https://devfeed.tech/topics/interfaces.md>), [Development](<https://devfeed.tech/topics/development.md>)

Tags: [classes](<https://devfeed.tech/tags/classes.md>), [code](<https://devfeed.tech/tags/code.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [design-patterns](<https://devfeed.tech/tags/design-patterns.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>)

### AI overview

The article defines "object incest" as a design anti-pattern in which two unrelated classes depend directly on each other. It explains that splitting a class without removing mutual dependencies still violates separation of concerns, and recommends extracting roles into interfaces so the classes depend on abstractions instead.

### Source excerpt

Note: I thought I had read this term from somewhere else, but after a quick internet search turned up only dirty videos, I think I may be the sole "coiner" of the term. Many inexperience developers (and experienced ones too) have been known to make several common mistakes in object oriented design. Hence, the coining of the terms anti-pattern and code smell to refer to patterns of development (like design patterns) that lead to convoluted, overly complex code that costs exponentially to maintain and exhibits little value.Object incest is a pattern where two unrelated classes are intimately dependent on each other. Simply put, if object A directly relies on object B and B relies directly on A, you have two incestual objects. This usually happens to intermediate developers who realize that they need separation of concerns and break a class into two classes without actually breaking the dependencies. While it is understandable (and almost respectable) why a developer might commit object incest, it is no less dangerous and harmful to a code base full of child objects.Here is an example of object incest:class Brother { public Sister MySister { get; set; } private void GetMyHairBrushed() { MySister.BrushHair(this); } public void DefendFromBullies(Sister sis) { // ... }}class Sister { public Brother MyBrother { get; set; } public void BrushHair(Brother bro) { // ... } private void GetRidOfBullies() { MyBrother.DefendFromBullies(this); }}This is wrong because the two objects are so involved that it's hard to tell them apart, breaking the principal of separation of concerns. You can fix this by extracting roles from the objects as interfaces. Therefore, each object depends on some kind of object that can fulfill a role. A brother object needs someone to brush his hair, a sister needs someone to defend her from bullies.class Brother : IDefenderOfTheWeak, IPersonWithHair { public IHairBrusher MyHairBrushPartner { get; set; } private void BrushMyHair() { MyHairBrushPartner.Brus

## Writing Object-Oriented JavaScript in a Python-Inspired Style

DevFeed: [Writing Object-Oriented JavaScript in a Python-Inspired Style](<https://devfeed.tech/articles/easy-object-oriented-javascript-the-python-way-35392.md>)

Original publisher: [Read original article](<https://darkcoding.net/software/easy-object-oriented-javascript-the-python-way/>)

Author: Graham King

Published: 2009-01-22T23:47:30Z

Content type: tutorial

Language: en

Sources: [Graham King](<https://devfeed.tech/sources/graham-king.md>)

Topics: [JavaScript](<https://devfeed.tech/topics/javascript.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [constructor](<https://devfeed.tech/tags/constructor.md>), [function](<https://devfeed.tech/tags/function.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [module](<https://devfeed.tech/tags/module.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [properties](<https://devfeed.tech/tags/properties.md>), [prototype](<https://devfeed.tech/tags/prototype.md>), [python](<https://devfeed.tech/tags/python.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

A tutorial that translates a whimsical Moose Observation Project from Python to JavaScript and explains how to structure object-oriented JavaScript. It covers namespaces, constructor functions, the new operator, prototype methods, and instance properties.

### Source excerpt

"Making Javascript look like Python: A whimsical Moose Observation Project"