Category Archives: Object Oriented Programming

Domain-Driven Design: Links, News, Resources (1)

More than four years (!) ago, I wrote down a list of DDD resources:

Domain-Driven Design Resources

Now, it’s time to publish a new (partial) list of resources. First, Wikipedia definition:

Domain-Driven Design

Domain-driven design (DDD) is an approach to developing software for complex needs by deeply connecting the implementation to an evolving model of the core business concepts.[1] The premise of domain-driven design is the following:

  • Placing the project’s primary focus on the core domain and domain logic
  • Basing complex designs on a model
  • Initiating a creative collaboration between technical and domain experts to iteratively cut ever closer to the conceptual heart of the problem.

Domain-driven design is not a technology or a methodology. DDD provides a structure of practices and terminology for making design decisions that focus and accelerate software projects dealing with complicated domains.

The term was coined by Eric Evans in his book of the same title.[2]

My recent links:

Domain-Driven Design Community

Skills Matter : DDD eXchange 2011: Udi Dahan on Domain Model

RESTful SOA or Domain-Driven Design – A Compromise?

Review: Microsoft N Layer App Sample, Part IV-IoC FTW – Ayende @ Rahien

Aggregate | Domain-Driven Design Community

Services in Domain-Driven Design | Jimmy Bogard’s Blog

Sample Application First Steps

Composition Patterns « Caminao’s Ways

Skills Matter : DDD eXchange 2011: Patrik Fredriksson on DDD

Skills Matter : DDD eXchange 2011 10-06-11

Skills Matter : In The Brain of Greg Young: CQRS, not just f

Domain Drive Design N-Layered .NET 4.0 Architecture Guide

What is Domain Driven Design? – Jak Charlton – Insane World – – Just the Tasty Bits

Eben Roux | Aggregate Roots vs. Single Responsibility (and other issues)

Eben Roux | DDD != Aggregate Root!3d-AR.aspx

Eben Roux | Natural Aggregates vs Synthetic Aggregates

Coding Instinct: Queries & Aggregates & DDD

Repository is Dead: Long Live Repository | Greg Young

domaindrivendesign : Message: What is wrong with aggregate roots?

DDD: Specifications, Language, and Locality | Greg Young

Domain Driven Design with Spring and AspectJ – Java Code Geeks

Objects_of_Value_KevlinHenney.pdf (application/pdf Object)


HunabKu: Repository or DAO?: Repository

Example: TDD, DDD, CQRS, Service Bus, Dependecy Injection, Logging, HTTP RPC, Data Access Abstraction, Custom ORM, Composite UI

JavATE – Welcome to JavATE The domain driven framework

ndddsample – Google Code


Bastion DDD Java Framework

Sharp Architecture – S#arp Architecture

NerdDinner with Fluent NHibernate Part 1 – The domain model

From CRUD to Domain-Driven Fluency

Think DDD

My links:

Keep tuned!

Angel “Java” Lopez

Links, news, Resources: Object Oriented Programming (1)

I’m a compulsive link collector 😉 (you can check my delicious links to see what I means). I usually share my links, news, discoveries via my Twitter feed, too. It’s time to share some of the links by topic. Let start with one: Object Oriented Programming. I will use the list to my own consumption, too 😉

Avoiding Dependencies
Insidious Dependencies
Avoid Entrenched Dependencies
Interesting entries by Steve Smith, to learn about dependencies between our objects and their consequences

InfoQ: Classes Are Premature Optimizations

Justin Love discusses the difference between the classic OOP programming model based on classes and prototypal inheritance built on objects as done in JavaScript, and how they affect performance.

He mentions Smalltalk and Self, too. Link via @HernanWilkinson.

Mixins vs Traits
Stackoverflow discussion: What is the difference between Mixins and Traits? Link via @jfroma.

Interfaces are not abstractions
To discuss:

the proliferation of interfaces that typically follow from TDD or use of DI may not be the pure goodness we tend to believe.

Modelos de Software con Objetos
@HernanWilkinson’s Spanish blog, about software models with objects.

Mi idea es postear lo que conozco sobre modelar/desarrollar con objetos, en base a lo que damos en la materia de POO y DAO de la UBA y mi experiencia personal

Going completely prototypal in JavaScript

In this post we present the Proto API which implements inheritance in JavaScript in a purely prototypal fashion. This contrasts it with all other JavaScript inheritance APIs that the author is aware of.

Hardware support for Objects: The MUSHROOM Project
A Distributed Multi-user Object-Oriented Programming Environment, with object-based memory.

In 1986 a group at the University of Manchester embarked upon an investigation into how developments in computer architecture could benefit the performance of dynamic object-oriented languages. We reasoned that if the object-oriented approach was of such great benefit to software development, then it would be all the more attractive if there was little loss of performance. Over the next five years we developed an architecture to support object-oriented languages, called the Mushroom architecture. The aim of the research was, starting with carte blanche, to discover what sort of architecture was best suited to Smalltalk-like languages.

Job Security through Code Obscurity
Use objects to obfuscate your code, specialize via inheritance, use lot of patterns, obscure code flow with virtuals and templates, include everything and more.

A non-hierarchical approach to object-oriented programming
Remember Flavors, object-oriented extension to Lisp.

Organic Programming
A Generative, Iterative and Pattern Language Independent (GIPLI) aproach to creating timeless Domain Specific Languages (DSL).

Solving the Expression Problem with OOP

The problem is, in a nutshell, how do you build an extensible data model and an extensible operation model that meets three goals: Code-level modularization, Separate compilation, Static type safety

Adding Dynamic Interfaces to Smalltalk

In this article we present SmallInterfaces; a new ontology of dynamic interfaces which makes a powerful use of the dynamic nature of Smalltalk. SmallInterfaces adds interfaces as honorary members to Smalltalk’s extensive reflection mechanism, in a manner portable across the many Smalltalk variants.


Trylon is a computer language. It is basically a cross between Python and Smalltalk. It uses indentation for program structure, like Python, and it uses Smalltalk’s expression syntax (but with precedence). Its objects are dynamically typed, but its programs are statically compiled (via C).

Object-Oriented PHP for Beginners

you’ll learn the concepts behind object-oriented programming (OOP), a style of coding in which related actions are grouped into classes to aid in creating more-compact, effective code.

To have gettters or not? Encapsulation vs use

SOLID by example
Source code examples in .NET, to understand SOLID principles.

The Open/Closed Principle: Concerns about Change in Software Design

This post investigates the applicability of the “Open/Closed Principle” when we add new functionality to a software design whose source code is entirely under our control.

Agent nouns are code smells
Discussion about: class names ending with agent nouns are a code smell (agent nouns as “helper”, “manager”)

Coding: The agent noun class
Mark Needham response to the above post.

OOP: What does an object’s responsibility entail? at Mark Needham

I believe that an object should be responsible for deciding how its data is used rather than having another object reach into it, retrieve its data and then decide what to do with it.

LDNUG : Mixing functional and object oriented approaches to programming in C#
Video of a talk by Mike Wagg and Mark Needham

Enough for this post. I will write more topic links posts.

Keep tuned!

Angel “Java” Lopez