Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T21:35:01Z

Wikimaster: /* Anemic Domain Model */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti-patterns were used,
*Lack of knowledge by the programmer who coded the system.
*Inexperience on the part of the programmer.
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==
Some of the widely used anti-patterns are classified into the following categories,
* [http://en.wikipedia.org/wiki/Anti-pattern#Organizational_anti-patterns Organizational anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Project_management_anti-patterns Project management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Analysis_anti-patterns Analysis anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Software_design_anti-patterns Software design anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Configuration_management_anti-patterns Configuration management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Programming_anti-patterns Programming anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Methodological_anti-patterns Methodological anti-patterns]

==Software design anti-patterns==
Some of the important software design anti-patterns are,
===Abstraction Inversion===
Abstraction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the index to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
**[http://en.wikipedia.org/wiki/Mutex Mutexes] can be used to address this problem in concurrent programming.

===Magic Pushbutton===
This is a very common anti-pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this are,
* The code for in those defined functions grow large.
* Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
* Testing becomes an issue.
 
*'''Example'''
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by re-factoring the business logic. In the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

*'''Solution'''
**Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

 

==Object-oriented design anti-patterns==
Some of the important Object-oriented design anti-patterns are,

===Anemic Domain Model===
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anemic Model is given below,
*'''Example'''
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

*'''Solution'''
**Although, the above code looks right by providing segregation of data and service, its in violation of OOPs principle of data and behavior [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are multiple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

 

===BaseBean===
In the practice of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go.

*'''Solution'''
**We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.
 

===CallSuper===
CallSuper is a anti-pattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practice because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsibility on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
*'''Example'''
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==
The significance of anti-patterns is the same as design patterns, anti-patterns are real helpful in identifying bad design.Thus the beforehand knowledge of anti-patterns comes in handy in making sure that the code base doesn't make use any of it. They should be identified at early stage of [http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle SDLC life cycle], because it might require significant effort to remove anti-patterns as you go down the SDLC life cycle.

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T21:34:25Z

Wikimaster: /* Software design anti-patterns */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti-patterns were used,
*Lack of knowledge by the programmer who coded the system.
*Inexperience on the part of the programmer.
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==
Some of the widely used anti-patterns are classified into the following categories,
* [http://en.wikipedia.org/wiki/Anti-pattern#Organizational_anti-patterns Organizational anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Project_management_anti-patterns Project management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Analysis_anti-patterns Analysis anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Software_design_anti-patterns Software design anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Configuration_management_anti-patterns Configuration management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Programming_anti-patterns Programming anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Methodological_anti-patterns Methodological anti-patterns]

==Software design anti-patterns==
Some of the important software design anti-patterns are,
===Abstraction Inversion===
Abstraction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the index to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
**[http://en.wikipedia.org/wiki/Mutex Mutexes] can be used to address this problem in concurrent programming.

===Magic Pushbutton===
This is a very common anti-pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this are,
* The code for in those defined functions grow large.
* Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
* Testing becomes an issue.
 
*'''Example'''
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by re-factoring the business logic. In the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

*'''Solution'''
* Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

 

==Object-oriented design anti-patterns==
Some of the important Object-oriented design anti-patterns are,

===Anemic Domain Model===
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
*'''Example'''
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

*'''Solution'''
**Although, the above code looks right by providing segregation of data and service, its in violation of OOPs principle of data and behavior [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are multiple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

 
===BaseBean===
In the practice of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go.

*'''Solution'''
**We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.
 

===CallSuper===
CallSuper is a anti-pattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practice because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsibility on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
*'''Example'''
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==
The significance of anti-patterns is the same as design patterns, anti-patterns are real helpful in identifying bad design.Thus the beforehand knowledge of anti-patterns comes in handy in making sure that the code base doesn't make use any of it. They should be identified at early stage of [http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle SDLC life cycle], because it might require significant effort to remove anti-patterns as you go down the SDLC life cycle.

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T21:31:45Z

Wikimaster: /* Object-oriented design anti-patterns */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti-patterns were used,
*Lack of knowledge by the programmer who coded the system.
*Inexperience on the part of the programmer.
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==
Some of the widely used anti-patterns are classified into the following categories,
* [http://en.wikipedia.org/wiki/Anti-pattern#Organizational_anti-patterns Organizational anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Project_management_anti-patterns Project management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Analysis_anti-patterns Analysis anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Software_design_anti-patterns Software design anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Configuration_management_anti-patterns Configuration management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Programming_anti-patterns Programming anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Methodological_anti-patterns Methodological anti-patterns]

==Software design anti-patterns==
===Abstraction Inversion===
Abstraction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the index to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
**Mutexes can be used to address this problem in concurrent programming.

===Magic Pushbutton===
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this are,
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
 
*'''Example'''
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by re-factoring the business logic. In the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

*'''Solution'''
**Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

 
==Object-oriented design anti-patterns==
Some of the important Object-oriented design anti-patterns are,

===Anemic Domain Model===
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
*'''Example'''
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

*'''Solution'''
**Although, the above code looks right by providing segregation of data and service, its in violation of OOPs principle of data and behavior [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are multiple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

 
===BaseBean===
In the practice of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go.

*'''Solution'''
**We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.
 

===CallSuper===
CallSuper is a anti-pattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practice because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsibility on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
*'''Example'''
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==
The significance of anti-patterns is the same as design patterns, anti-patterns are real helpful in identifying bad design.Thus the beforehand knowledge of anti-patterns comes in handy in making sure that the code base doesn't make use any of it. They should be identified at early stage of [http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle SDLC life cycle], because it might require significant effort to remove anti-patterns as you go down the SDLC life cycle.

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T21:30:00Z

Wikimaster: /* Object-oriented design anti-patterns */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti-patterns were used,
*Lack of knowledge by the programmer who coded the system.
*Inexperience on the part of the programmer.
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==
Some of the widely used anti-patterns are classified into the following categories,
* [http://en.wikipedia.org/wiki/Anti-pattern#Organizational_anti-patterns Organizational anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Project_management_anti-patterns Project management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Analysis_anti-patterns Analysis anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Software_design_anti-patterns Software design anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Configuration_management_anti-patterns Configuration management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Programming_anti-patterns Programming anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Methodological_anti-patterns Methodological anti-patterns]

==Software design anti-patterns==
===Abstraction Inversion===
Abstraction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
**Mutexes can be used to address this problem in concurrent programming.

===Magic Pushbutton===
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this are,
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
 
*'''Example'''
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by re-factoring the business logic. In the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

*'''Solution'''
**Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==
Some of the important Object-oriented design anti-patterns are,

===Anemic Domain Model===
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
*'''Example'''
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

*'''Solution'''
**Although, the above code looks right by providing segregation of data and service, its in violation of OOPs principle of data and behavior [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are multiple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

 
===BaseBean===
In the practice of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go.

*'''Solution'''
**We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.
 

===CallSuper===
CallSuper is a anti-pattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practice because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsibility on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
*'''Example'''
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==
The significance of anti-patterns is the same as design patterns, anti-patterns are real helpful in identifying bad design.Thus the beforehand knowledge of anti-patterns comes in handy in making sure that the code base doesn't make use any of it. They should be identified at early stage of [http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle SDLC life cycle], because it might require significant effort to remove anti-patterns as you go down the SDLC life cycle.

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T21:29:17Z

Wikimaster: /* Object-oriented design anti-patterns */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti-patterns were used,
*Lack of knowledge by the programmer who coded the system.
*Inexperience on the part of the programmer.
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==
Some of the widely used anti-patterns are classified into the following categories,
* [http://en.wikipedia.org/wiki/Anti-pattern#Organizational_anti-patterns Organizational anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Project_management_anti-patterns Project management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Analysis_anti-patterns Analysis anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Software_design_anti-patterns Software design anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Configuration_management_anti-patterns Configuration management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Programming_anti-patterns Programming anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Methodological_anti-patterns Methodological anti-patterns]

==Software design anti-patterns==
===Abstraction Inversion===
Abstraction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
**Mutexes can be used to address this problem in concurrent programming.

===Magic Pushbutton===
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this are,
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
 
*'''Example'''
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by re-factoring the business logic. In the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

*'''Solution'''
**Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==
Some of the important Object-oriented design patterns are,

===Anemic Domain Model===
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
*'''Example'''
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

*'''Solution'''
**Although, the above code looks right by providing segregation of data and service, its in violation of OOPs principle of data and behavior [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are multiple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behavior (debit method) into BankAccnt Class.

 
===BaseBean===
In the practice of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go.

*'''Solution'''
**We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.
 

===CallSuper===
CallSuper is a anti-pattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practice because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsibility on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
*'''Example'''
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==
The significance of anti-patterns is the same as design patterns, anti-patterns are real helpful in identifying bad design.Thus the beforehand knowledge of anti-patterns comes in handy in making sure that the code base doesn't make use any of it. They should be identified at early stage of [http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle SDLC life cycle], because it might require significant effort to remove anti-patterns as you go down the SDLC life cycle.

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T21:26:26Z

Wikimaster: /* BaseBean */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==
Some of the widely used anti-patterns are classified into the following categories,
* [http://en.wikipedia.org/wiki/Anti-pattern#Organizational_anti-patterns Organizational anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Project_management_anti-patterns Project management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Analysis_anti-patterns Analysis anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Software_design_anti-patterns Software design anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Configuration_management_anti-patterns Configuration management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Programming_anti-patterns Programming anit-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Methodological_anti-patterns Methodological anti-patterns]

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
**Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this are,
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
 
*'''Example'''
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

*'''Solution'''
**Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

===Anemic Domain Model===
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
*'''Example'''
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

*'''Solution'''
**Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

 
===BaseBean===
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go.

*'''Solution'''
**We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.
 

===CallSuper===
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
*'''Example'''
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==
The significance of anti-patterns is the same as design patterns, anti-patterns are real helpful in identifying bad design.Thus the beforehand knowledge of anti-patterns comes in handy in making sure that the codebase doesn't make use any of it. They should be identified at early stage of [http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle SDLC life cycle], because it might require significant effort to remove anti-patterns as you go down the SDLC life cycle.

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T21:25:43Z

Wikimaster: /* BaseBean */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==
Some of the widely used anti-patterns are classified into the following categories,
* [http://en.wikipedia.org/wiki/Anti-pattern#Organizational_anti-patterns Organizational anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Project_management_anti-patterns Project management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Analysis_anti-patterns Analysis anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Software_design_anti-patterns Software design anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Configuration_management_anti-patterns Configuration management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Programming_anti-patterns Programming anit-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Methodological_anti-patterns Methodological anti-patterns]

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
**Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this are,
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
 
*'''Example'''
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

*'''Solution'''
**Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

===Anemic Domain Model===
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
*'''Example'''
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

*'''Solution'''
**Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

===BaseBean===
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go.

*'''Solution'''
**We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.
 

===CallSuper===
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
*'''Example'''
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==
The significance of anti-patterns is the same as design patterns, anti-patterns are real helpful in identifying bad design.Thus the beforehand knowledge of anti-patterns comes in handy in making sure that the codebase doesn't make use any of it. They should be identified at early stage of [http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle SDLC life cycle], because it might require significant effort to remove anti-patterns as you go down the SDLC life cycle.

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T21:21:37Z

Wikimaster: /* Conclusion */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==
Some of the widely used anti-patterns are classified into the following categories,
* [http://en.wikipedia.org/wiki/Anti-pattern#Organizational_anti-patterns Organizational anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Project_management_anti-patterns Project management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Analysis_anti-patterns Analysis anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Software_design_anti-patterns Software design anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Configuration_management_anti-patterns Configuration management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Programming_anti-patterns Programming anit-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Methodological_anti-patterns Methodological anti-patterns]

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
**Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this are,
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
 
*'''Example'''
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

*'''Solution'''
**Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

===Anemic Domain Model===
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
*'''Example'''
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

*'''Solution'''
**Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

===BaseBean===
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go.

*'''Solution'''
**We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

===CallSuper===
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
*'''Example'''
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==
The significance of anti-patterns is the same as design patterns, anti-patterns are real helpful in identifying bad design.Thus the beforehand knowledge of anti-patterns comes in handy in making sure that the codebase doesn't make use any of it. They should be identified at early stage of [http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle SDLC life cycle], because it might require significant effort to remove anti-patterns as you go down the SDLC life cycle.

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T21:21:08Z

Wikimaster: /* Conclusion */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==
Some of the widely used anti-patterns are classified into the following categories,
* [http://en.wikipedia.org/wiki/Anti-pattern#Organizational_anti-patterns Organizational anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Project_management_anti-patterns Project management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Analysis_anti-patterns Analysis anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Software_design_anti-patterns Software design anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Configuration_management_anti-patterns Configuration management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Programming_anti-patterns Programming anit-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Methodological_anti-patterns Methodological anti-patterns]

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
**Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this are,
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
 
*'''Example'''
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

*'''Solution'''
**Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

===Anemic Domain Model===
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
*'''Example'''
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

*'''Solution'''
**Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

===BaseBean===
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go.

*'''Solution'''
**We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

===CallSuper===
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
*'''Example'''
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==
The significance of anti-patterns is the same as design patterns, anti-patterns are real helpful in identifying bad design.Thus the beforehand knowledge of anti-patterns comes in handy in making sure that the codebase doesn't make use any of it. They should be identified at early stage of [http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle SDLC life cycle], because it might require significant effort to remove anti-patterns as go down the SDLC life cycle.

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T21:20:48Z

Wikimaster: /* Conclusion */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==
Some of the widely used anti-patterns are classified into the following categories,
* [http://en.wikipedia.org/wiki/Anti-pattern#Organizational_anti-patterns Organizational anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Project_management_anti-patterns Project management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Analysis_anti-patterns Analysis anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Software_design_anti-patterns Software design anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Configuration_management_anti-patterns Configuration management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Programming_anti-patterns Programming anit-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Methodological_anti-patterns Methodological anti-patterns]

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
**Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this are,
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
 
*'''Example'''
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

*'''Solution'''
**Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

===Anemic Domain Model===
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
*'''Example'''
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

*'''Solution'''
**Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

===BaseBean===
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go.

*'''Solution'''
**We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

===CallSuper===
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
*'''Example'''
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==
The Significance of anti-patterns is the same as design patterns, anti-patterns are real helpful in identifying bad design.Thus the beforehand knowledge of anti-patterns comes in handy in making sure that the codebase doesn't make use any of it. They should be identified at early stage of [http://en.wikipedia.org/wiki/Systems_Development_Life_Cycle SDLC life cycle], because it might require significant effort to remove anti-patterns as go down the SDLC life cycle.

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T21:03:23Z

Wikimaster: /* Anemic Domain Model */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==
Some of the widely used anti-patterns are classified into the following categories,
* [http://en.wikipedia.org/wiki/Anti-pattern#Organizational_anti-patterns Organizational anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Project_management_anti-patterns Project management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Analysis_anti-patterns Analysis anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Software_design_anti-patterns Software design anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Configuration_management_anti-patterns Configuration management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Programming_anti-patterns Programming anit-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Methodological_anti-patterns Methodological anti-patterns]

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
**Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this are,
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
 
*'''Example'''
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

*'''Solution'''
**Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

===Anemic Domain Model===
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
*'''Example'''
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

*'''Solution'''
**Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

===BaseBean===
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go.

*'''Solution'''
**We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

===CallSuper===
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
*'''Example'''
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T21:02:46Z

Wikimaster: /* BaseBean */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==
Some of the widely used anti-patterns are classified into the following categories,
* [http://en.wikipedia.org/wiki/Anti-pattern#Organizational_anti-patterns Organizational anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Project_management_anti-patterns Project management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Analysis_anti-patterns Analysis anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Software_design_anti-patterns Software design anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Configuration_management_anti-patterns Configuration management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Programming_anti-patterns Programming anit-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Methodological_anti-patterns Methodological anti-patterns]

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
**Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this are,
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
 
*'''Example'''
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

*'''Solution'''
**Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

===Anemic Domain Model===
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
*'''Example'''
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

*'''Solution'''
Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

===BaseBean===
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go.

*'''Solution'''
**We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

===CallSuper===
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
*'''Example'''
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T21:01:39Z

Wikimaster: /* Known classifications */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==
Some of the widely used anti-patterns are classified into the following categories,
* [http://en.wikipedia.org/wiki/Anti-pattern#Organizational_anti-patterns Organizational anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Project_management_anti-patterns Project management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Analysis_anti-patterns Analysis anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Software_design_anti-patterns Software design anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Configuration_management_anti-patterns Configuration management anti-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Programming_anti-patterns Programming anit-patterns]
* [http://en.wikipedia.org/wiki/Anti-pattern#Methodological_anti-patterns Methodological anti-patterns]

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
**Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this are,
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
 
*'''Example'''
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

*'''Solution'''
**Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

===Anemic Domain Model===
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
*'''Example'''
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

*'''Solution'''
Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

===BaseBean===
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go.

*'''Solution'''
We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

===CallSuper===
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
*'''Example'''
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:52:00Z

Wikimaster: /* Object-oriented design anti-patterns */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
**Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this are,
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
 
*'''Example'''
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

*'''Solution'''
**Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

===Anemic Domain Model===
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
*'''Example'''
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

*'''Solution'''
Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

===BaseBean===
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go.

*'''Solution'''
We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

===CallSuper===
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
*'''Example'''
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:49:34Z

Wikimaster: /* Magic Bushbutton */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
**Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this are,
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
 
*'''Example'''
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

*'''Solution'''
**Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

* Anemic Domain Model
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

* BaseBean
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go. We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

* CallSuper
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:48:27Z

Wikimaster: /* Solution */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
**Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.

*'''Example'''
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

*'''Solution'''
**Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

* Anemic Domain Model
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

* BaseBean
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go. We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

* CallSuper
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:47:39Z

Wikimaster: /* Example */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
**Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.

*'''Example'''
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

====Solution====
*Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

* Anemic Domain Model
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

* BaseBean
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go. We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

* CallSuper
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:47:10Z

Wikimaster: /* Race Hazard */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
**Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.

====Example====
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

====Solution====
*Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

* Anemic Domain Model
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

* BaseBean
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go. We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

* CallSuper
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:46:44Z

Wikimaster: /* Definition */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.

====Example====
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

====Solution====
*Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

* Anemic Domain Model
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

* BaseBean
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go. We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

* CallSuper
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:46:21Z

Wikimaster: /* Solution */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

*'''Solution'''
Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
====Definition====
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
====Example====
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

====Solution====
*Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

* Anemic Domain Model
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

* BaseBean
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go. We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

* CallSuper
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:45:47Z

Wikimaster: /* Example */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

*'''Example'''
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

====Solution====
Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
====Definition====
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
====Example====
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

====Solution====
*Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

* Anemic Domain Model
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

* BaseBean
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go. We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

* CallSuper
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:45:11Z

Wikimaster: /* Definition */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

====Example====
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

====Solution====
Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
====Definition====
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
====Example====
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

====Solution====
*Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

* Anemic Domain Model
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

* BaseBean
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go. We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

* CallSuper
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:44:50Z

Wikimaster: /* Big ball of mud */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
**Good understanding of the system prior to any major code changes.
**Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
**Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
====Definition====
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

====Example====
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

====Solution====
Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
====Definition====
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
====Example====
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

====Solution====
*Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

* Anemic Domain Model
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

* BaseBean
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go. We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

* CallSuper
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:44:17Z

Wikimaster: /* Solution */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

*'''Solution'''
*Good understanding of the system prior to any major code changes.
*Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
*Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
====Definition====
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

====Example====
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

====Solution====
Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
====Definition====
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
====Example====
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

====Solution====
*Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

* Anemic Domain Model
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

* BaseBean
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go. We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

* CallSuper
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:43:40Z

Wikimaster: /* Example */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

*'''Example'''
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

====Solution====
*Good understanding of the system prior to any major code changes.
*Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
*Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
====Definition====
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

====Example====
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

====Solution====
Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
====Definition====
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
====Example====
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

====Solution====
*Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

* Anemic Domain Model
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

* BaseBean
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go. We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

* CallSuper
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:43:04Z

Wikimaster: /* Definition */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===

This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.

====Example====
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

====Solution====
*Good understanding of the system prior to any major code changes.
*Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
*Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
====Definition====
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

====Example====
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

====Solution====
Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
====Definition====
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
====Example====
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

====Solution====
*Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

* Anemic Domain Model
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

* BaseBean
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go. We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

* CallSuper
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:42:19Z

Wikimaster: /* Abstraction Inversion */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* '''Example'''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* '''Solution'''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===
====Definition====
This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.
====Example====
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

====Solution====
*Good understanding of the system prior to any major code changes.
*Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
*Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
====Definition====
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

====Example====
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

====Solution====
Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
====Definition====
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
====Example====
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

====Solution====
*Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

* Anemic Domain Model
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

* BaseBean
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go. We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

* CallSuper
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:41:08Z

Wikimaster: /* Abstraction Inversion */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* ''Example''
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* ''Solution''
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===
====Definition====
This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.
====Example====
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

====Solution====
*Good understanding of the system prior to any major code changes.
*Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
*Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
====Definition====
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

====Example====
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

====Solution====
Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
====Definition====
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
====Example====
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

====Solution====
*Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

* Anemic Domain Model
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

* BaseBean
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go. We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

* CallSuper
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:39:34Z

Wikimaster: /* Abstraction Inversion */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* Example
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

* Solution
**Choose the infrastructure carefully.
**If the system offers w=equivalent functions, use them.
**Do not inject any weak constructs into the system.

===Big ball of mud===
====Definition====
This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.
====Example====
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

====Solution====
*Good understanding of the system prior to any major code changes.
*Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
*Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
====Definition====
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

====Example====
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

====Solution====
Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
====Definition====
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
====Example====
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

====Solution====
*Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

* Anemic Domain Model
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

* BaseBean
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go. We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

* CallSuper
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:38:46Z

Wikimaster: /* Solution */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* Example
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

** Solution
*Choose the infrastructure carefully.
*If the system offers w=equivalent functions, use them.
*Do not inject any weak constructs into the system.

===Big ball of mud===
====Definition====
This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.
====Example====
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

====Solution====
*Good understanding of the system prior to any major code changes.
*Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
*Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
====Definition====
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

====Example====
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

====Solution====
Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
====Definition====
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
====Example====
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

====Solution====
*Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

* Anemic Domain Model
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

* BaseBean
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go. We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

* CallSuper
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:38:11Z

Wikimaster: /* Example */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

* Example
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.

====Solution====
*Choose the infrastructure carefully.
*If the system offers w=equivalent functions, use them.
*Do not inject any weak constructs into the system.

===Big ball of mud===
====Definition====
This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.
====Example====
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

====Solution====
*Good understanding of the system prior to any major code changes.
*Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
*Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
====Definition====
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

====Example====
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

====Solution====
Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
====Definition====
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
====Example====
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

====Solution====
*Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

* Anemic Domain Model
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

* BaseBean
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go. We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

* CallSuper
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-17T20:37:12Z

Wikimaster: /* Definition */

=Anti-patterns=

==Overview==
Anti-patterns is a type of design which when used may result in the code being unproductive and ineffective. It commonly describes a commonly occurring solution to a problem that may have negative consequences. There are many reasons as to why the anti pattern was used,
*Lack of knowledge by the programmer who coded the system
*Inexperience on the part of the programmer
*Lack of proper understanding of the functionality the system needed to provide.
Anti-Patterns highlight the most common problems that face the software industry and provide the tools to enable you to recognize these problems and to determine their underlying causes.[http://en.wikipedia.org/wiki/Anti-pattern]

==Known classifications==

==Software design anti-patterns==
===Abstraction Inversion===
Abstarction Inversion means implementing a lower level construct on top of high level constructs. A simple example would be suppose we have 2 constructs A and B. Let B be implemented on top of A but A is not exposed anywhere in the system and if we really require A then we end up building A on top of B and B was already implemented in terms of A.
A short Example of Abstraction Inversion is given below

====Example====
The below code implements a set of binary values in a String which decide if it is true or false. (e.g. 'T' or 'F'). They then use the indexer to find the bit.
char[] bitString ...;
if (bitString[i] == 'T') { // do stuff

So in this case we have a character representing a bit value, but a character is nothing but a sequence of bits. Therefore we have a sequence made up of characters containing bits which are made up of a bit sequence.
====Solution====
*Choose the infrastructure carefully.
*If the system offers w=equivalent functions, use them.
*Do not inject any weak constructs into the system.

===Big ball of mud===
====Definition====
This term was coined by Brain Foote and Joseph Yoder's paper in 1999. This kind of anti pattern arises over a period of time where a number of programmers have worked on a system on various pieces of code. Dur to the lack of knowledge of the current systems the programmers write code which may have already been present and results in a lot of redundant code. Information being shared across the system which may result in it being globally declared and eventually making the code unreadable and unmanageable.
====Example====
float CalculateTotal(int quantity, float price){
return quantity*price;
}

float CalculateAmount(int amt, float price){
return amt*price;
}

The above code shows two functions that perform the same function but was created which results in code redundancy and unreadable.

====Solution====
*Good understanding of the system prior to any major code changes.
*Modularizing the code and defining the functionality at the proper location can help reduce the code redundancy.
*Technical shifts(client-server to web based, file based to database based etc) can provide good reasons to create the system from scratch.

===Race Hazard===
====Definition====
A race hazard or a race condition is a flaw in the system where the output of the system depends on the order in which the system executes. This leads to inconsistency in the output. This term was coined with the idea of two signals racing each other to influence each other.

====Example====
global integer A = 0;
//increments the value of A and prints "RX"
// activated whenever an interrupt is received from the controller
task Received()
{
A = A + 1
print RX
}

//prints out only even numbers
//is activated whenever an interrupt is received from the serial controller
task timeout()
{
if(A is divisible by 2)
{
print A
}
}

Output would look like
0
0
0
RX
RX
2
RX
RX
4

====Solution====
Mutexes can be used to address this problem in concurrent programming.

===Magic Bushbutton===
====Definition====
This is a very common anti pattern that shows up on graphical user interfaces programming environments. The user first draws the user interface and then builds up the business logic in the automatically created methods.
Some of the issues faced in this
*The code for in those defined functions grow large.
*Change in the user interface leads to a lot of changes in the functions and becomes difficult to manage.
*Testing becomes an issue.
====Example====
Below is a Bad example of Magic PushButton Anti Pattern.
procedure TForm1.ButtonClick(Sender: TObject);
var
reg:TRegistry;
begin
reg:TRegistry.Create;
try
reg.RootKey:= HKey_Current_User;
if reg.OpenKey('\Software\mycompany',true) then
begin
reg.WriteString('Filename',edit1.text);
end;
finally
reg.Free;
end
end

A good example of the same is given below. This is done by refactoring the business logic. IN the below example this is done by storing the file in an registry in a separate class.

type
TReference = class
private
FFilename: string
procedure SetFilename(const Value: string)
public
property Filename:string read FFilename write SetFilename;
procedure Load;
procedure Save;
end

The above code will call Save method from the click handler.
procedure TForm1.ButtonClick (Sender: Object);
begin
Preference.Save;
end;
procedure TForm1.EditChange (Sender: TObject);
begin
Preferences.Filename:= edit1.text;
end;

====Solution====
*Create functions and modularize the code as much as possible so that the code could be well maintained and flexible.

==Object-oriented design anti-patterns==

* Anemic Domain Model
Separating the [http://en.wikipedia.org/wiki/Business_logic business logic] from the [http://en.wikipedia.org/wiki/Domain_model Domain Model] is termed as Anemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's [http://en.wikipedia.org/wiki/Entity_Bean Entity beans] and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour [http://en.wikipedia.org/wiki/Encapsulation encapsulation].It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

* BaseBean
In the practise of BaseBean, subclasses are derived from an utility class, even though delegation is possible. [http://en.wikipedia.org/wiki/Inheritance Inheritance] can be evil sometimes, either breaking some subclass due to change in parent class or very deep hierarchy of classes leading to confusion and no reuse of code. For example, if we want to create a student class and we already have person class, inheritance is not the right way to go. We can use delegation and create instance of Person class in Student class and utilize all the features of class Person in class Student.

* CallSuper
CallSuper is a antipattern in which subclass [http://en.wikipedia.org/wiki/Method_overriding overrides] a parent's method and calls the parent's overridden method from the same method. This is considered as a bad practise because, in the future if the parent class's implementation changes it breaks the subclass too. And also it puts an additional responsiblity on the subclass's developer to call Super.The correct way to go about this is the parent class declaring a separate hook method for subclass to override.
// '''Wrong Way''' // '''Correct Way'''
public class EventHandle{ public class EventHandle{
public void handle (BankingEvent e) { public void handle (BankingEvent e) {
cleanUp(e); cleanUp(e);
} doHandle(e); //hook method
} }
public class TransferEventHandler extends EventHandle{ protected void doHandle(BankingEvent e) {
public void handle(BankingEvent e) { }
super.handle(e); public class TransferEventHandler extends EventHandle{
initiateTransfer(e); protected void doHandle(BankingEvent e) {
} initiateTransfer(e);
}
} }

==Conclusion==

==See also==

* [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) Design Patterns]
* [http://en.wikipedia.org/wiki/Code_smell Code Smell]

==References==

* [http://en.wikipedia.org/wiki/Abstraction_inversion Abstraction Inversion]
* [http://en.wikipedia.org/wiki/Big_ball_of_mud Big Ball Of Mud]
* [http://en.wikipedia.org/wiki/Race_hazard Race Hazard]
* [http://en.wikipedia.org/wiki/Magic_pushbutton Magic Pushbutton]
* [http://en.wikipedia.org/wiki/Anti-pattern Anti-pattern]
* [http://en.wikipedia.org/wiki/Anemic_Domain_Model Anemic Domain Model]
* [http://en.wikipedia.org/wiki/BaseBean BaseBean]

==External Links==

[1] http://www.antipatterns.com/ 
[2] http://c2.com/cgi/wiki?AntiPattern 
[3] http://www.martinfowler.com/bliki/CallSuper.html 
[4] AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown and Raphael C.Malveau

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-16T04:16:14Z

Wikimaster: /* Object-oriented design anti-patterns */

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-16T02:07:37Z

Wikimaster: /* Object-oriented design anti-patterns */

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-16T02:07:09Z

Wikimaster: /* Object-oriented design anti-patterns */

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-16T02:06:38Z

Wikimaster: /* Object-oriented design anti-patterns */

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-16T02:03:28Z

Wikimaster: /* Object-oriented design anti-patterns */

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-16T02:01:09Z

Wikimaster: /* References */

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-16T01:58:46Z

Wikimaster: /* See also */

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-16T01:56:53Z

Wikimaster: /* External Links */

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-16T01:52:38Z

Wikimaster: /* External Links */

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-16T01:52:09Z

Wikimaster: /* External Links */

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-16T01:51:11Z

Wikimaster: /* External Links */

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-16T01:45:52Z

Wikimaster: /* Object-oriented design anti-patterns */

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-16T01:38:31Z

Wikimaster: /* Object-oriented design anti-patterns */

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-16T01:34:30Z

Wikimaster: /* Object-oriented design anti-patterns */

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-13T03:14:09Z

Wikimaster: /* Object-oriented design anti-patterns */

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-13T03:12:55Z

Wikimaster: /* Object-oriented design anti-patterns */

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-13T00:43:42Z

Wikimaster: /* Object-oriented design anti-patterns */

=Anti-patterns=

==Overview==
==Known classifications==

==Software design anti-patterns==
===Object-oriented design anti-patterns===

* Anaemic Domain Model
Separating the business logic from the Domain Model is termed as Anaemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's Entity beans and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segregation of data and service, its in violation of OOP principle of data and behaviour encapsulation.It could run into problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to manually check for account type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

==See also==
==References==
==External Links==

CSC/ECE 517 Fall 2009/wiki3 1 kp

2009-11-13T00:42:20Z

Wikimaster: /* Object-oriented design anti-patterns */

=Anti-patterns=

==Overview==
==Known classifications==

==Software design anti-patterns==
===Object-oriented design anti-patterns===

* Anaemic Domain Model
Separating the business logic from the Domain Model is termed as Anaemic Domain Model.One of the prime reason for it being popular is, it provides separation of logic and data. To site few places this is used are Java's Entity beans and .Net's three layered service application. A short example for Anaemic Model is given below,
class BankAccnt {
private double balance;
public void setBalance(double balance) {
this.balance = balance;
}
class AccntService {
public void debit(Account account, double amount) {
account.setBalance(account.getBalance() - amount);
}
}

Although, the above code looks right by providing segration of data and service, its in violation of OOP principle of data and behaviour encapsulation.It could lead to problems when there are muliple type of accounts and some of them have overdraft protection, then debit method has to check for accoount type.This can be corrected by moving the behaviour (debit method) into BankAccnt Class.

==See also==
==References==
==External Links==