I am reviewing my knowledge in object-oriented programming. Under the relationship between classes topic, I have encountered some relationships which are a bit ambiguous to me.

I know dependency &quot;uses-a&quot; and inheritance &quot;is-a&quot; but I&#39;m a bit unfamiliar with Aggregation, Composition, Association and Direct Association; also, which of them is &quot;has-a&quot; relationship. Some use Aggregation interchangeably with Association.

What is Direct Association? Also, what is Composition? In UML diagrams, the arrows that represents them are different. I would be really thankful if you could clear these things out for me.

Aggregation vs Composition vs Association vs Direct Association

What are the differences between service orchestration and service choreography from an intra-organization point of view.


Orchestration vs. Choreography

Are Composition and Inheritance the same?
If I want to implement the composition pattern, how can I do that in Java?

Difference between Inheritance and Composition

Many template languages have &quot;slots&quot; or &quot;yield&quot; statements, that allow to do some sort of inversion of control to wrap one template inside of another.

Angular has [&quot;transclude&quot; option](http://docs.angularjs.org/guide/directive#creating-custom-directives_demo_creating-a-directive-that-wraps-other-elements).

Rails has [yield statement](http://guides.rubyonrails.org/layouts_and_rendering.html#understanding-yield). If React.js had yield statement, it would look like this:

    var Wrapper = React.createClass({
      render: function() {
        return (
          &lt;div className=&quot;wrapper&quot;&gt;
            before
              &lt;yield/&gt;
            after
          &lt;/div&gt;
        );
      }
    });

    var Main = React.createClass({
      render: function() {
        return (
          &lt;Wrapper&gt;&lt;h1&gt;content&lt;/h1&gt;&lt;/Wrapper&gt;
        );
      }
    });


Desired output:

    &lt;div class=&quot;wrapper&quot;&gt;
      before
        &lt;h1&gt;content&lt;/h1&gt;
      after
    &lt;/div&gt;

Alas, React.js doesn’t have a `&lt;yield/&gt;`. How do I define Wrapper component to achieve the same output?

React.js: Wrapping one component into another

I&#39;m aware of the conceptual differences between Aggregation and Composition. Can someone tell me the implementation difference in Java between them with examples? 

Implementation difference between Aggregation and Composition in Java

In F#, use of the the pipe-forward operator, `|&gt;`, is pretty common.  However, in Haskell I&#39;ve only ever seen function composition, `(.)`, being used.  I understand that they are [related][1], but is there a language reason that pipe-forward isn&#39;t used in Haskell or is it something else?


  [1]: http://blogs.msdn.com/chrsmith/archive/2008/06/14/function-composition.aspx

Haskell composition (.) vs F#&#39;s pipe forward operator (|&gt;)

What is the difference between association, aggregation, and composition? 
Please explain in terms of implementation.

What is the difference between association, aggregation and composition?

If I have two interfaces , both quite different in their purposes , but with same method signature , how do I make a class implement both without being forced to write a single method that serves for the both the interfaces and writing some convoluted logic in the method implementation that checks for which type of object the call is being made and invoke proper code ?

In C# , this is overcome by what is called as explicit interface implementation. Is there any equivalent way in Java ?
 

Java - Method name collision in interface implementation

Why prefer composition over inheritance?  What trade-offs are there for each approach?  When should you choose inheritance over composition?

Prefer composition over inheritance?

It is well-known that applicative functors are closed under composition but monads are not.  However, I have been having trouble finding a concrete counterexample showing that monads do not always compose.

[This answer](https://stackoverflow.com/a/7040998/305559) gives `[String -&gt; a]` as an example of a non-monad.  After playing around with it for a bit, I believe it intuitively, but that answer just says &quot;join cannot be implemented&quot; without really giving any justification.  I would like something more formal.  Of course there are lots of functions with type `[String -&gt; [String -&gt; a]] -&gt; [String -&gt; a]`; one must show that any such function necessarily does not satisfy the monad laws.

Any example (with accompanying proof) will do; I am not necessarily looking for a proof of the above example in particular.

Concrete example showing that monads are not closed under composition (with proof)?

In java world (more precisely if you have no multiple inheritance/mixins) the rule of thumb is quite simple: &quot;Favor object composition over class inheritance&quot;.  

I&#39;d like to know if/how it is changed if you also consider mixins, especially in scala?  
Are mixins considered a way of multiple inheritance, or more class composition?  
Is there also a &quot;Favor object composition over class composition&quot; (or the other way around) guideline?

I&#39;ve seen quite some examples when people use (or abuse) mixins when object composition could also do the job and I&#39;m not always sure which one is better. It seems to me that you can achieve quite similar things with them, but there are some differences also, some examples: 

* visibility - with mixins everything becomes part of the public api, which is not the case with composition. 
* verbosity - in most cases mixins are less verbose and a bit easier to use, but it&#39;s not always the case (e.g. if you also use self types in complex hierarchies)

I know the short answer is &quot;It depends&quot;, but probably there are some typical situation when this or that is better.

Some examples of guidelines I could come up with so far (assuming I have two traits A and B and A wants to use some methods from B):

* If you want to extend the API of A with the methods from B then mixins, otherwise composition. But it does not help if the class/instance that I&#39;m creating is not part of a public API.
* If you want to use some patterns that need mixins (e.g. [Stackable Trait Pattern][1]) then it&#39;s an easy decision. 
* If you have circular dependencies then mixins with self types can help. (I try to avoid this situation, but it&#39;s not always easy)
* If you want some dynamic, runtime decisions how to do the composition then object composition.

In many cases mixins seem to be easier (and/or less verbose), but I&#39;m quite sure they also have some pitfalls, like the &quot;God class&quot; and others described in two artima articles: [part 1][2], [part 2][3] (BTW it seems to me that most of the other problems are not relevant/not so serious for scala).

Do you have more hints like these?


  [1]: http://www.artima.com/scalazine/articles/stackable_trait_pattern.html
  [2]: http://www.artima.com/weblogs/viewpost.jsp?thread=246341
  [3]: http://www.artima.com/weblogs/viewpost.jsp?thread=246483

Mixins vs composition in scala

I have been doing SOLID in C# to a pretty extreme level in recent times and at some point realized I&#39;m essentially not doing much else than composing functions nowadays. And after I recently started looking at F# again, I figured that it would probably be the much more appropriate choice of language for much of what I&#39;m doing now, so I&#39;d like to try and port a real world C# project to F# as a proof of concept. I think I could pull off the actual code (in a very un-idiomatic fashion), but I can&#39;t imagine what an architecture would look like that allows me to work in a similarly flexible fashion as in C#.

What I mean by this is that I have lots of small classes and interfaces that I compose using an IoC container, and I also use patterns like Decorator and Composite a lot. This results in an (in my opinion) very flexible and evolvable overall architecture that allows me to easily replace or extend functionality at any point of the application. Depending on how big the required change is, I might only need to write a new implementation of an interface, replace it in the IoC registration and be done. Even if the change is bigger, I can replace parts of the object graph while the rest of the application simply stands as it did before.

Now with F#, I don&#39;t have classes and interfaces (I know I can, but I think that&#39;s beside the point when I want to do actual functional programming), I don&#39;t have constructor injection, and I don&#39;t have IoC containers. I know I can do something like a Decorator pattern using higher order functions, but that doesn&#39;t quite seem to give me the same kind of flexibility and maintainability as classes with constructor injection.


Consider these C# types:

&lt;!-- language: c# --&gt;

    public class Dings
    {
        public string Lol { get; set; }

        public string Rofl { get; set; }
    }

    public interface IGetStuff
    {
        IEnumerable&lt;Dings&gt; For(Guid id);
    }

    public class AsdFilteringGetStuff : IGetStuff
    {
        private readonly IGetStuff _innerGetStuff;

        public AsdFilteringGetStuff(IGetStuff innerGetStuff)
        {
            this._innerGetStuff = innerGetStuff;
        }

        public IEnumerable&lt;Dings&gt; For(Guid id)
        {
            return this._innerGetStuff.For(id).Where(d =&gt; d.Lol == &quot;asd&quot;);
        }
    }

    public class GeneratingGetStuff : IGetStuff
    {
        public IEnumerable&lt;Dings&gt; For(Guid id)
        {
            IEnumerable&lt;Dings&gt; dingse;

            // somehow knows how to create correct dingse for the ID

            return dingse;
        }
    }

I&#39;ll tell my IoC container to resolve `AsdFilteringGetStuff` for `IGetStuff` and `GeneratingGetStuff` for its own dependency with that interface. Now if I need a different filter or remove the filter altogether, I may need the respective implementation of `IGetStuff` and then simply change the IoC registration. As long as the interface stays the same, I don&#39;t need to touch stuff **within** the application. OCP and LSP, enabled by DIP.

Now what do I do in F#?

&lt;!-- language-all: f# --&gt;

	type Dings (lol, rofl) =
	    member x.Lol = lol
	    member x.Rofl = rofl
	
	let GenerateDingse id =
	    // create list
	    
	let AsdFilteredDingse id =
	    GenerateDingse id |&gt; List.filter (fun x -&gt; x.Lol = &quot;asd&quot;)

I love how much less code this is, but I lose flexibility. Yes, I can call `AsdFilteredDingse` or `GenerateDingse` in the same place, because the types are the same - but how do I decide which one to call without hard coding it at the call site? Also, while these two functions are interchangeable, I now cannot replace the generator function inside `AsdFilteredDingse` without changing this function as well. This isn&#39;t very nice.

Next attempt:

	let GenerateDingse id =
	    // create list
	    
	let AsdFilteredDingse (generator : System.Guid -&gt; Dings list) id =
	    generator id |&gt; List.filter (fun x -&gt; x.Lol = &quot;asd&quot;)

Now I have composability by making AsdFilteredDingse a higher order function, but the two functions are not interchangeable anymore. On second thought, they probably shouldn&#39;t be anyway.

What else could I do? I could mimic the &quot;composition root&quot; concept from my C# SOLID in the last file of the F# project. Most files are just collections of functions, then I have some kind of &quot;registry&quot;, which replaces the IoC container, and finally there is one function that I call to actually run the application and that uses functions from the &quot;registry&quot;. In the &quot;registry&quot;, I know I need a function of type (Guid -&gt; Dings list), which I&#39;ll call `GetDingseForId`. This is the one I call, never the individual functions defined earlier.

For the decorator, the definition would be

	let GetDingseForId id = AsdFilteredDingse GenerateDingse

To remove the filter, I&#39;d change that to

	let GetDingseForId id = GenerateDingse

The downside(?) of this is that all functions that use other functions would sensibly have to be higher order functions, and my &quot;registry&quot; would have to map **all** functions that I use, because the actual functions defined earlier can&#39;t call any functions defined later, in particular not those from the &quot;registry&quot;. I might also run into circular dependency issues with the &quot;registry&quot; mappings.


Does any of this make sense? How do you really build an F# application to be maintainable and evolvable (not to mention testable)?

Application architecture/composition in F#

I hear (and read on this site) a lot about &quot;favour composition over inheritance&quot;.

But what is Compositon? I understand inheritance from the point of Person : Mammal : Animal, but I can&#39;t really see the definition of Compostion anywhere.. Can somebody fill me in?

What is composition as it relates to object oriented design?

I know the question has been &lt;a href=&quot;https://stackoverflow.com/questions/49002/prefer-composition-over-inheritance&quot;&gt;discussed before&lt;/a&gt;, but it seems always under the assumption that inheritance is at least sometimes preferable to composition. I&#39;d like to challenge that assumption in hopes of gaining some understanding.

My question is this: &lt;em&gt;Since&lt;/em&gt; you can accomplish anything with object composition that you can with classical inheritance &lt;em&gt;and since&lt;/em&gt; classical inheritance is very often abused[1] &lt;em&gt;and since&lt;/em&gt; object composition gives you flexibility to change the delegate object runtime, &lt;strong&gt;why the would you &lt;em&gt;ever&lt;/em&gt; use classical inheritance?&lt;/strong&gt;

I can sort of understand why you would recommend inheritance in some languages like Java and C++ that do not offer convenient syntax for delegation. In these languages you can save a lot of typing by using inheritance whenever it is not clearly incorrect to do so. But other languages like Objective C and Ruby offer both classical inheritance &lt;em&gt;and&lt;/em&gt; very convienient syntax for delegation. The Go programming language is the only langage that to my knowledge has decided that classical inheritance is more trouble than it&#39;s worth and supports only delegation for code reuse. 

Another way to state my question is this: Even if you know that classical inheritance is not incorrect to implement a certain model, is that reason enough to use it instead of composition?

[1] Many people use classical inheritance to achieve polymorphism instead of letting their classes implement an interface. The purpose of inheritance is code reuse, not polymorphism. Furthermore, some people use inheritance to model their intuitive understanding of an &quot;is-a&quot; relationship &lt;a href=&quot;http://en.wikipedia.org/wiki/Circle-ellipse_problem&quot;&gt;which can often be problematic&lt;/a&gt;.

&lt;strong&gt;Update&lt;/strong&gt;

I just want to clarify what I mean exactly when I talk about inheritance:

I am talking about &lt;a href=&quot;http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)&quot;&gt;the kind of inheritance whereby a class inherits from a partially or fully implemented base class&lt;/a&gt;. I am &lt;em&gt;not&lt;/em&gt; talking about inheriting from a purely abstract base class which amounts to the same thing as implementing an interface, which I for the record am not arguing against.

&lt;strong&gt;Update 2&lt;/strong&gt;

I understand that inheritance is the only way to achieve polymorphism i C++. In that case it&#39;s obvious why you must use it. So my question is limited to languages such as Java or Ruby that offer distinct ways to achieve polymorphism (interfaces and duck typing, respectively).

Why use inheritance at all?

I am facing a continuing problem distinguishing delegation, composition and aggregation from each other, and identifying the cases where it&#39;s the best to use one over the other.

I have consulted a Java OO Analysis and Design book, but my confusion still remains. The main explanation is this:

**Delegation**: When my object uses another object&#39;s functionality as is without changing it.

**Composition**: My object consists of other objects which in turn cannot exist after my object is destroyed-garbage collected.

**Aggregation**: My object consists of other objects which can live even after my object is destroyed.

Is it possible to have a few simple examples demonstrating each case, and the reasoning behind them? How else can these examples be demonstrated other than my object simply having a reference to another object(s)?

Distinguishing between delegation, composition and aggregation (Java OO Design)

&lt;p&gt;I know that the compiler sometimes provides a default copy constructor if you don&#39;t implement yourself. I am confused about what exactly this constructor does. If I have a class that contains other objects, none of which have a declared copy constructor, what will the behavior be? For example, a class like this:&lt;/p&gt;
    class Foo {
      Bar bar;
    };

    class Bar {
      int i;
      Baz baz;
    };

    class Baz {
      int j;
    };
&lt;p&gt;Now if I do this:&lt;/p&gt;
    Foo f1;
    Foo f2(f1);
&lt;p&gt;What will the default copy constructor do? Will the compiler-generated copy constructor in &lt;code&gt;Foo&lt;/code&gt; call the compiler-generated constructor in &lt;code&gt;Bar&lt;/code&gt; to copy over &lt;code&gt;bar&lt;/code&gt;, which will then call the compiler-generated copy constructor in &lt;code&gt;Baz&lt;/code&gt;?

C++ implicit copy constructor for a class that contains other objects

There is a lot of information about composition vs inheritance online, but I haven&#39;t found decent examples with JavaScript. Using the below code to demonstrate inheritance:

    
    function Stock( /* object with stock names and prices */ ) {
        for (var company_name in arguments[0]) {
            // copy the passed object into the new object created by the constructor
            this[company_name] = arguments[0][company_name]; 
        }
    }
    
    // example methods in prototype, their implementation is probably redundant for
    // this question, but list() returns an array with toString() invoked; total()
    // adds up the stock prices and returns them. Using ES5 feature to make
    // inherited properties non-enumerable 
    
    Stock.prototype =  {
        list: function () {
            var company_list = [];
            for (var company_name in this)
                company_list.push(company_name);
            return company_list.toString();
        },
        total: function () {
            var price_total = 0;
            for (var company_name in this)
                price_total += this[company_name];
            return &#39;$&#39; + price_total;
        }
    };

    Object.defineProperties(Stock.prototype, {
        list: { enumerable: false },
        total: { enumerable:false }
    });
    
    var portfolio = new Stock({ MSFT: 25.96, YHOO: 16.13, AMZN: 173.10 });
    portfolio.list();  // MSFT,YHOO,AMZN
    portfolio.total(); // $215.19


(To make the code smaller, you can leave out the method implementations, like: `Stock.total = function(){ /* code */ }` I just put them in there to be fancy). If composition is favored for a lot of situations in OOP, how come most people using JavaScript seem to only use prototypes and inheritance? I did not find a lot of information about composition in JavaScript online, only in other languages.

Can someone give me an example using the above code to demonstrate composition and aggregation? 

All Composition Solutions on Gang of Coders

Total of 17 Composition Solutions