is found in a limited way in for instance Java and C++, where a child class constructor always calls the parent class constructor. Languages that support before and after methods, such as Common Lisp (specifically the Common Lisp Object System), provide a different way to avoid this anti-pattern. The subclass's programmer can, instead of overriding the superclass's method, supply an additional method which will be executed before or after the superclass's method. Also, the superclass's programmer can specify before, after, and around methods that are guaranteed to be executed in addition to the subclass's actions. Example Suppose there is a class for generating a report about the inventory of a video rental store. Each particular store has a different way of tabulating the videos currently available, but the algorithm for generating the final report is the same for all stores. A framework that uses the call super anti-pattern may provide the following abstract class (in C#): abstract class ReportGenerator { public virtual Report CreateReport() { // Generate the general report object // ... return new Report(...); } } A user of the class is expected to implement a subclass like this: class ConcreteReportGenerator : ReportGenerator { public override Report CreateReport() { // Tabulate data in the store-specific way // ... // Design of this class requires the parent CreateReport() function to be called at the // end of the overridden function. But note this line could easily be left out, or the // returned report could be further modified after the call, violating the class design // and possibly also the company-wide report format. return base.CreateReport(); } } A preferable interface looks like this: abstract class ReportGenerator { public Report CreateReport() { Tabulate(); // Generate the general report object // ... return new Report(...); } protected abstract void Tabulate(); } An implementation would override this class like this: class ConcreteReportGenerator : ReportGenerator { protected override void Tabulate() { // Tabulate data in the store-specific way // ... } } References Anti-patterns Object-oriented programming