Version 2.0

Welcome,
Version 2.0 is currently in public beta. Comments and feedback are much appreciated. Check it out here
Thanks and enjoy playing.

Structural patterns – Decorator

After discussing creational patterns, which handle object creation throughout the application, it’s time to take a look at how objects are composed in order to create flexible larger structures. Structural patterns deal with the way objects connect with each other to form new objects, or modify object capabilities and they offer flexible solutions to common [...]

Dynamic object creation – Prototype

When it comes to creating new objects dynamically, an application needs to able to instantiate and remove objects at run-time. This becomes particularly difficult if the concrete classes describe similar objects that only vary in representation, because you could end up with a lot of subclasses for basically the same kind of product. Enter the [...]

Factory patterns – Abstract Factory

Now that we have looked at the Factory Method pattern, which delegates the responsibility, of deciding which objects to create, to its subclasses, we’ll be analyzing the Abstract Factory pattern, which is used for created multiple objects from the same family, by providing a common interface for creation. In the words of the Gang of [...]

Another creational pattern – Factory method

Many might argue that this should be the first topic when learning design patterns, and they could be right, but I’m documenting them in cronological learning order. So here we are today discussing the Factory Method pattern, a very simple and useful way of designing the part of an application responsible for creating new objects.
The [...]

Veedeonic is back in development

Veedeonic – our online video sharing platform is back on track.
In December Software Magic started working on version 2 of veedeonic.com. Due to internal issues the application in it’s version 1 couldn’t be released for the public until now. With development well on the way we are pleased to announce that the new version [...]

Rethinking the Builder

Picking up on the last post, and following Alex’s advice, I have decided to rewrite the example for the Builder pattern. Read about the new and improved form Builder…

Now, I mainly use PHP (as you can obviously tell) and some details are harder to notice (or understand, for that matter) than in other languages (like, [...]

Understanding the Builder pattern

Following the previous post on the Singleton design pattern, this article will discuss some features of the Builder pattern.
First thing’s first. As a creational pattern, the Builder pattern deals with creation of new items throught the application, but unlike the Singleton, which has the main focus of creating a globally avaible instace of an object, [...]

Learning Design Patterns – One at a time

Most of us programmers, are very attached to our code, and find beauty not just in the end result (the working application), but also in the architecture and the actual code. As I am sure you’ve heared many times before, “Code is poetry”. And nowhere else is this concept more palpable then in Object-Oriented Programming.
The [...]

Smarty pages

In practice, developers often encounter the situation when a page needs to display a set of items (products, users etc) on sepparate pages which can be accessed using the previous/next navigation links. All though it is not a difficult matter, if you’re implementing this in a page that uses smarty templates, it might seem more difficult to implement. This article discusses how you can display an array of items on pages, each page containing a set amount of items using Smarty for formatting the items, and later on jQuery for navigating between pages.

« Older Entries