You may have heard the expression “prefer composition over inheritance“.
But what does it really mean? What’s wrong with inheritance? Even the Wikipedia article on composition over inheritance is using classes and inheritance to explain composition. If composition is so much better than inheritance (at least sometimes), then why do we have to explain composition in terms of inheritance? And why do most modern programming languages and platforms support classes and inheritance syntactically but not composition? What would a programming language even look like if it had syntactic support for composition? Furthermore, what even is the design pattern for composition?
Many of the examples you see from cursory searches online simply show one class containing references to others and that’s about it. This kind of overly simple example seems to acknowledge the problem without really explaining the full solution and it’s completely framed in a context of inheritance. Simply introducing classes containing references to other classes doesn’t give us enough information to establish a pattern and it ends up raising more questions than it answers.
One really good example of composition can be found in Unity3D. Composition in Unity3D is a first class concept that runs very deeply into the built-in game engine that drives everything that Unity does. After studying it for a while I would like to use the patterns of composition found in Unity as a basis for our design pattern and our hypothetical programming language.
Aspects of the Composition Pattern
In a compositional system you therefore need at least two kinds of Types:
- Object
- Component
The Object in a compositional system is not the same as an Object in an inheritance based system. An Object in a minimal compositional system has the following attributes:
- It may have a name
- It may posses child objects
- It may have a parent object
- It may contain named components
- It can send messages to components
A Component has the following attributes:
- It has a reference to the Object it is contained by
- It may have data
- It can handle messages
Simple Example
If we were to design a minimal version of this system (in C#) it may look something like this:
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| interface IObject | |
| { | |
| string Name { get; } | |
| IObject Parent { get; } | |
| void Add(string name, IComponent component); | |
| void Add(IObject child); | |
| void Remove(IObject child); | |
| IComponent GetComponent(string name); | |
| IEnumerable<IObject> GetChildren(); | |
| void SendMessage(string message, params object[] parameters); | |
| } | |
| interface IComponent | |
| { | |
| IObject Object { get; } | |
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // A naieve implementation of SendMessage | |
| public void SendMessage(string message, params object[] parameters) | |
| { | |
| var types = parameters.Select(a => a == null ? typeof(object) : a.GetType()).ToArray(); | |
| foreach (var component in this.components.Values) | |
| { | |
| var method = component.GetType().GetMethod(message, types); | |
| if (method != null) | |
| { | |
| // Call methods on the component via reflection | |
| method.Invoke(component, parameters); | |
| } | |
| } | |
| } |
For a more robust example I highly recommend studying Unity3D in detail. However the question I am asking is what would a system like this look like if it was not framed in the context of classes. How would it look if it were to have syntactic support in a language instead of simply implemented as a design pattern in terms of inheritance? I don’t fully know the answer to this question but I have been experimenting with some ideas and would like to have a discussion around them.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| component c1 { | |
| function receive(message: string) { // handles "receive" messages | |
| print(message) | |
| } | |
| } | |
| component c2 { | |
| var running: bool | |
| function run() { // Handles the "run" message | |
| if(!running) | |
| running = true | |
| this–>receive("hello world!") // Sends a message to "receive" with an argument | |
| else | |
| this–>receive("error!") | |
| } | |
| } | |
| // An object containing the above components | |
| var x = { | |
| c1 = new c1() | |
| c2 = new c2() | |
| } | |
| // send a message to components on x named "run" | |
| x–>run() // > hello world! | |
| x–>run() // > error! |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| var x = { } // an empty object | |
| var y = { | |
| value: "hi" // any value type, not a function | |
| } | |
| var z = Root { // a named object | |
| } | |
| var j = Root { // An object with children | |
| First { | |
| } | |
| Second { | |
| } | |
| } | |
| for(var child in j) { | |
| print(child.name) // First, Second | |
| } | |
| j.First.foo() // Get child named "First" send it a message named "foo" |
The first thing to realize with this system is that instead of designing Objects up front with static definitions like classes you can only instantiate them and you can only design their hierarchy.
Components are more interesting and do have a static definition. They contain state like a class which means they fulfill the OO principle of encapsulation. They may handle messages of any shape which also means they are polymorphic but they are not inheritable in this system. You may be tempted to add inheritance to components at this point but I believe that this is unnecessary and a mistake. The reason for this is that inheritance is basically just another kind of relationship but it is one that has a much higher degree of coupling between objects. There are a variety of reasons why this form of relationship can cause problems. One is the lack of abstraction and thus isolating the unit for test can become very complex and costly. Instead of using inheritance simply break out shared behavior and state into even more, smaller and more focused components.
A composition system like this is actually similar to the DOM you would find in a browser. The primary differences are that in this case it would not be tied specifically to a single domain (e.g. the domain of laying out and rendering documents) and instead of using an event system it uses message passing. In this way composition allows us to be extremely loosely coupled without requiring extra abstractions.
I can imagine systems where, instead of having a component keyword in the language, you compile entire files into components similar to the way you would compile an entire file into a module in a CommonJS system such as node.js. Your main app would essentially setup your starting objects the rest of your files would be Components. These ideas are very powerful I believe. The game industry has known about them and has been perfecting them for quite some time now, while the rest of the programming community appears to be largely unaware as far as I can tell. I would love to see some experimentation with these ideas in non game domains and find out what the community can come up with.
You must be logged in to post a comment.