vote up
0
vote down

Practical Php Patterns: Observer

This post is part of the Practical Php Pattern series. Today's pattern is the Observer one. The intent of this pattern is breaking a [usually one-to-many] dependency between objects by making the set of objects act as Observers of a Subject one, which
Invisible to the eye
 
Giorgio
tags: oop
Mar 09 2010 06:12 PM
vote up
0
vote down

Practical Php Patterns: Memento

This post is part of the Practical Php Pattern series. The pattern of today is the Memento one, whose intent is storing the state of an Originator object without breaking its encapsulation, which typically consists in a set of private fields. For the
Invisible to the eye
 
Giorgio
tags: oop
Mar 03 2010 06:59 PM
vote up
0
vote down

Practical Php Patterns: Mediator

This post is part of the Practical Php Pattern series.   The pattern of the day is the Mediator one. The intent of this pattern is encapsulating the interactions of a set of objects, preventing aggressive coupling from each of them towards the other
Invisible to the eye
 
Giorgio
tags: oop
Mar 01 2010 06:17 PM
vote up
0
vote down

The 50000 feet view and Dependency Injection

One criticism of Dependency Injection is the supposed unnecessary abstraction over collaborators that it is imposed by the constructor and setter injection techniques. Writing: class Computer {     public function __construct(Cpu $cpu) {  
Invisible to the eye
 
Giorgio
tags: oop
Feb 23 2010 06:54 PM
vote up
0
vote down

Objects to Unify Type Classes and GADTs

Objects to Unify Type Classes and GADTs, by Bruno C. d. S. Oliveira and Martin Sulzmann: We propose an Haskell-like language with the goal of unifying type classes and generalized algebraic datatypes (GADTs) into a single class construct. We treat
Lambda the Ultimate - Programming Languages Weblog
 
tags: functional object-functional oop theory
Feb 23 2010 04:18 AM
vote up
0
vote down

Practical Php Patterns: Iterator

This post is part of the Practical Php Pattern series.   The behavioral pattern of the day is the Iterator pattern, which provides an abstraction over a very common process: the iteration over a collection of objects [or scalars] located in an
Invisible to the eye
 
Giorgio
tags: oop
Feb 22 2010 07:58 PM
vote up
0
vote down

The Number one rule of design

The post on php's foreach construct raised a discussion about the design of the language and of userland code, so I'm recollecting my thoughts here. However, note that I was not discussing the utility of the construct, only the use of array functions
Invisible to the eye
 
Giorgio
tags: oop
Feb 19 2010 10:24 PM
vote up
0
vote down

Practical Php Patterns: Interpreter

This post is part of the Practical Php Pattern series.   The behavioral pattern of today is the Interpreter pattern, which consists in a representation of a grammar with a Composite class hierarchy, where rules are mapped to classes. An expressio
Invisible to the eye
 
Giorgio
tags: oop
Feb 18 2010 06:06 PM
vote up
0
vote down

Testing protected members

This is a follow-up to Testing private members. In the previous post, we discussed how to make sure that code in a private method is tested without accessing it directly, since that would imply the use of reflection and a violation of the class contract
Invisible to the eye
 
Giorgio
tags: oop
Feb 16 2010 10:08 PM
vote up
0
vote down

Joe-E: A Security-Oriented Subset of Java

Joe-E: A Security-Oriented Subset of Java. Adrian Mettler, David Wagner, and Tyler Close. To appear at ISOC NDSS 2010. We present Joe-E, a language designed to support the development of secure software systems. Joe-E is a subset of Java that makes it
Lambda the Ultimate - Programming Languages Weblog
 
tags: oop semantics
Feb 16 2010 01:42 PM
vote up
0
vote down

Practical Php Patterns: Command

This post is the second one in the behavioral patterns part of the Practical Php Pattern series. The behavioral pattern we will discuss today is the Command one, a mechanism for encapsulation of a generic operation. If you are familiar with C or Php, you
Invisible to the eye
 
Giorgio
tags: oop
Feb 11 2010 07:29 PM
vote up
0
vote down

Testing private members

Yesterday, Sebastian Bergmann, the author of PHPUnit, posted his response to a question he is asked frequently, How do I test private members of a class? He summarizes the ways to access private fields and methods of an object from a PHPUnit test case,
Invisible to the eye
 
Giorgio
tags: oop
Feb 10 2010 08:15 PM
vote up
0
vote down

Practical Php Patterns: Chain of Responsibility

This post starts the behavioral patterns part of the Practical Php Pattern series. The first behavioral pattern of this part of the series is named Chain of Responsibility. Its intent is organizing a chain of objects to handle a request such as a method
Invisible to the eye
 
Giorgio
tags: oop
Feb 09 2010 04:44 PM
vote up
0
vote down

Design Patterns - The Command Pattern

There's a lot of knowledge in the book Design Patterns (Gang of Four). Developers should know the material in there to write efficient and maintainable code, but the book is pretty dry. I'd say it's quicker and easier to just point curious folks at the
Multiple Hats
 
Dean Jackson
tags: oop
Feb 08 2010 09:41 PM
vote up
0
vote down

Practical Php Patterns: Structural patterns summary

This post is part of the Practical Php Pattern series. The GoF book says there is a lot of similarity between structural patterns because of the few kinds of relationships in object model structures: inheritance and implementation between classes plus
Invisible to the eye
 
Giorgio
tags: oop
Feb 08 2010 07:41 PM
vote up
0
vote down

Practical Php Patterns: Proxy

This post is part of the Practical Php Pattern series.   The structural pattern of today is the Proxy pattern, an enhancement on the simple handler (or pointer) used as a reference to an object: this pointer is substituted by a Proxy object which
Invisible to the eye
 
Giorgio
tags: oop
Feb 04 2010 08:57 PM
vote up
1
vote down

Practical Php Patterns: Facade

This post is part of the Practical Php Pattern series. The structural pattern of today is the Facade one. A Facade is a class that provides a unified interface to a subsystem, totally abstracting away the concrete classes which compose it. The Client is
Invisible to the eye
 
Giorgio
tags: oop
Jan 29 2010 10:38 PM
vote up
0
vote down

Practical Php Patterns: Decorator

This post is part of the Practical Php Pattern series. Today we will explore the Decorator pattern, an alternative to subclassing which favors object composition over class inheritance. A common issue of subclassing is its rigidity: when different
Invisible to the eye
 
Giorgio
tags: oop
Jan 25 2010 07:04 PM
vote up
0
vote down

Practical Php Patterns: Composite

This post is part of the Practical Php Pattern series. One of the most important structural patterns is the Composite one: its goal is managing a hierarchy of objects where both leaf objects and composition of other objects conform to a common interface.
Invisible to the eye
 
Giorgio
tags: oop
Jan 20 2010 09:38 PM
vote up
0
vote down

Relationships between objects

This article implements the beginner pattern, but it can also be useful to recap the terms we use lightheartedly in discussions about object-oriented programming. In the definitions, we will talk about a relationship between a Source and Target objects,
Invisible to the eye
 
Giorgio
tags: oop
Jan 19 2010 08:10 PM
vote up
0
vote down

Practical Php Patterns: Bridge

This post is part of the Practical Php Pattern series. Today we will explore the Bridge pattern, whose intent is separating an abstraction from its implementation to improve decoupling and allowing them both to change independently. Commonly an
Invisible to the eye
 
Giorgio
tags: oop
Jan 18 2010 10:40 PM
vote up
0
vote down

Practical Php Patterns: Adapter

This post starts the Structural patterns part of the Practical Php Pattern series. Structural patterns are concerned with the structure of the object graph, and influence the hierarchy of subclassing, and where to introduce interfaces and associations.
Invisible to the eye
 
Giorgio
tags: oop
Jan 15 2010 07:14 PM
vote up
0
vote down

Practical Php Patterns: Creational patterns summary

This post is part of the Practical Php Pattern series. It's useful to dedicate a post to summarize the various creational patterns we have studied so far. The goal of this recap is to outline differences between patterns to analyze each one's
Invisible to the eye
 
Giorgio
tags: oop
Jan 14 2010 07:28 PM
vote up
0
vote down

Practical Php Patterns: Singleton

This is the fifth post from the Practical Php Pattern series, which will touch the majority of the known design patterns, with a special look at their application in a php context and code samples. Today we will discuss the Singleton pattern, the most
Invisible to the eye
 
Giorgio
tags: oop
Jan 13 2010 10:04 PM
vote up
0
vote down

Practical Php Patterns: Prototype

This is the fourth post from the Practical Php Pattern series, which will touch the majority of the known design patterns, with a special look at their application in a php context and code samples. Today we will discuss the Prototype pattern. The
Invisible to the eye
 
Giorgio
tags: oop
Jan 12 2010 06:36 PM
vote up
0
vote down

Practical Php Patterns: Factory Method

This is the third post from the Practical Php Pattern series, which will touch the majority of the known design patterns, with a special look at their application in a php context and code samples. The third creational pattern we will study is the
Invisible to the eye
 
Giorgio
tags: oop
Jan 11 2010 07:20 PM
vote up
0
vote down

Encapsulation in JavaScript

Encapsulation is a useful technique in programming which allows you to separate an abstraction’s implementation from its interface, thus enabling future changes to the implementation without affecting the interface. There are other benefits of
James Padolsey
 
James
tags: javascript oop
Jan 09 2010 07:57 PM
vote up
0
vote down

Practical Php Patterns: Builder

This is the second post from the Practical Php Pattern series, which would touch the majority of the known design patterns, with a special look at their application in a php context. A running code sample will be provided for each part of this series.
Invisible to the eye
 
Giorgio
tags: oop
Jan 08 2010 06:32 PM
vote up
0
vote down

Practical Php Patterns: Abstract Factory

This is the first installment of the Practical Php Patterns series, which would touch the majority of the known design patterns, with a special look at their application in a php context. A running code sample will be provided for each part of this
Invisible to the eye
 
Giorgio
tags: oop
Jan 07 2010 07:19 PM
vote up
0
vote down

OOP: Behavioural and Structural constraints

A few months ago I wrote a post describing how we should test the behaviour of code rather than the implementation whereby we would write tests against the public API of an object rather than exposing other internal data of the object and testing against
Mark Needham
 
Mark Needham
tags: oop
Dec 31 2009 10:23 PM
vote up
0
vote down

OOP: Behavioural and Structural constraints

A few months ago I wrote a post describing how we should test the behaviour of code rather than the implementation whereby we would write tests against the public API of an object rather than exposing other internal data of the object and testing against
Mark Needham
 
Mark Needham
tags: oop
Dec 31 2009 09:44 PM
vote up
0
vote down

Super and Inner - Together at Last!

Super and Inner - Together at Last! by David S. Goldberg, Robert Bruce Findler, and Matthew Flatt, 2004. In an object-oriented language, a derived class may declare a method with the same signature as a method in the base class. The meaning of the
Lambda the Ultimate - Programming Languages Weblog
 
tags: oop
Dec 22 2009 04:16 PM
vote up
0
vote down

How to implement OOP Polymorphism in Rebol

According to Wikipedia: Parametric polymorphism is a way to make a language more expressive, while still maintaining full static type-safety. A function that can evaluate to or be applied to values of different types is known as a polymorphic
Rebol Tutorial
 
admin
tags: all concept oop polymorphism
Dec 19 2009 02:06 AM
vote up
0
vote down

How to group related Global Objects / Functions into "Modules"

When program grows, best practice is to organize source code by modules. There’s no explicit concept of “Module” per se in Rebol 2 unlike other languages like Ruby and of course Java, .NET, etc. but Rebol could have the same kind of
Rebol Tutorial
 
admin
tags: all beginner concept oop
Dec 19 2009 01:03 AM
vote up
0
vote down

How Dynamically Extend an Object

Dynamic Languages are hot today since people now realize that static language properties are less suitable for some kind of tasks like Behavior Driven Development. Javascript Framework like Prototype has a method for extending an object, and even now
Rebol Tutorial
 
admin
tags: all beginner oop syntax
Dec 17 2009 10:08 PM
vote up
0
vote down

The object graph

Stefano wrote to me with the intention to expand the discussion on the object graph concept, which I referred to earlier. As always, I think that sharing my thoughts can help other readers and also provide some feedback about these ideas. A bit of theory
Invisible to the eye
 
Giorgio
tags: oop
Dec 16 2009 04:54 PM
vote up
0
vote down

Going Hybrid - Implementing a Shopping Cart in F#

One persistent question that keeps coming up to me is how to merge functional programming techniques with object oriented techniques that many are used to.  My usual reply is to talk about how functional programming affects your code, programming in
CodeBetter.Com - Stuff you need to Code Better!
 
Matthew.Podwysocki
tags: f# functional programming oop
Dec 15 2009 06:08 AM
vote up
0
vote down

How an Orm works

Some readers have been confused by the terms I use often in reference to Object relational mappers, so I want to describe some concepts of Orms and make some definitions. Particularly I want to focus on how a real Orm works and lets you write classes
Invisible to the eye
 
Giorgio
tags: oop
Dec 14 2009 10:39 PM
vote up
0
vote down

Creating an OOP Class-Based Language with an Homoiconic / Prototype-Based OOP Language

In some previous article, I have simulated the Val keyword in Scala. My Ambition as Creator being growing with time, I wana now simulate a Whole Universe (not yet) Language System such as Java, C#, PHP, javascript … well that’s the start :).
Rebol Tutorial
 
admin
tags: all oop
Dec 13 2009 04:17 PM
vote up
0
vote down

What everybody ought to know about storing objects in a database

Probably during your career you have heard the term impedance mismatch, which is commonly referred to the problems that arise in converting data between different models (or between different cables if you are into electrical engineering). Usually the
Invisible to the eye
 
Giorgio
tags: oop
Dec 09 2009 09:23 PM