Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-28T03:30:27Z

Yliu63: /* A mixed example using Singleton Factory and Command */

= Introduction =
The purpose of the wiki is to introduce and show some example about pattern fragility. The contents include definition of pattern fragility and what does the concept cover. We also give some examples of mistakes in code that spoil the benefits of design patterns.

= Design Patterns =
A design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be transformed directly into source or machine code. It is a description or template for how to solve a problem that can be used in many different situations. Patterns are formalized best practices that the programmer must implement themselves in the application. Object-oriented design patterns typically show relationships and interactions between classes or objects, without specifying the final application classes or objects that are involved. Many patterns imply object-orientation or more generally mutable state, and so may not be as applicable in functional programming languages, in which data is immutable or treated as such.
== Why Design Patterns ==
A design pattern is a pattern—a way to pursue an intent—that uses classes and their methods in an object-oriented language. Developers often start thinking about design after learning a programming language and writing code for a while. You might notice that someone else’s code seems simpler and works better than yours does, and you might wonder how that developer achieves such simplicity. Design patterns are a level up from code and typically show how to achieve a goal using a few classes. A pattern represents an idea, not a particular implementation.

== Categorization of Patterns ==
{| class="wikitable"
|-
! Intent !! Patterns
|-
| Interfaces || ADAPTER, FACADE, COMPOSITE, BRIDGE
|-
| Responsibility || SINGLETON, OBSERVER, MEDIATOR, PROXY, CHAIN OF RESPONSIBILITY, FLYWEIGHT
|-
| Construction || BUILDER, FACTORY METHOD, ABSTRACT FACTORY, PROTOTYPE, MEMENTO
|-
| Operations|| TEMPLATE METHOD, STATE, STRATEGY, COMMAND, INTERPRETER
|-
| Extensions || DECORATOR, ITERATOR, VISITOR
|}

== Benefits of Design Patterns ==
Design patterns provide a way of encapsulating the experience of software developers in a form that can be communicated to other developers. They provide a higher level of abstraction than single classes and objects thus providing bigger building blocks in the construction of software designs.

The main benefits of design patterns are:

*They encapsulate and codify design experience.
*Provide a common vocabulary for software designers to use when communicating with their peers.
*Enhance maintainability of software systems whose designs are documented with patterns.
*Provide robustness to the design by copying or imitating proven design techniques.
*Reuse at the design level.

At first glance some of these benefits may not seem very powerful, but upon further inspection maybe we can gain new insight into the true nature of their value. Let us just consider the fact that we have given a design pattern a common name. We can now communicate an entire design principle or concept with other software developers by just using the simple name of the pattern. In one fell swoop we have drastically reduced the effort and time needed for a developer to discuss a concept with another developer. Taken one step further we can discuss the patterns and their interactions in the system and illustrate the system architecture in few sentences. Grouping design concepts with common names facilitates communication among developers and raises the conversation to a higher level of abstraction.

= Pattern Fragility =
== Symptoms of Rotting Design ==
There are four primary symptoms that tell us that our designs are rotting. They are not orthogonal, but are related to each other in ways that will become obvious.

The four symptoms are:
*Rigidity -- the tendency for software to be difficult to change, even in simple ways.
*Fragility -- the tendency of the software to break in many places every time it is changed.
*Immobility -- the inability to reuse software from other projects or from parts of the same project.
*Viscosity -- viscosity comes in two forms: viscosity of the design, and viscosity of the environment.

In following passage of this wiki page, we will discuss over 'Fragility' with some examples.

== Definition of Pattern Fragility ==
Fragility is the tendency of the
software to break in many places every time it is changed. Often the breakage occurs
in areas that have no conceptual relationship with the area that was changed. Such
errors fill the hearts of managers with foreboding. Every time they authorize a fix,
they fear that the software will break in some unexpected way.
As the fragility becomes worse, the probability of breakage increases with time,
asymptotically approaching 1. Such software is impossible to maintain. Every fix
makes it worse, introducing more problems than are solved.
Such software causes managers and customers to suspect that the developers have lost
control of their software. Distrust reigns, and credibility is lost.

== Examples ==
=== Singleton -- the most overused pattern ===

Sometimes it's important to have only one instance for a class. For example, in a system there should be only one window manager (or only a file system). Usually singletons are used for centralized management of internal or external resources and they provide a global point of access to themselves. The primary purpose of the singleton is to guarantee that at anytime there is only one instance for a given class and provide a global reference to it.

The singleton pattern is one of the simplest design patterns: it involves only one class which is responsible to instantiate itself, to make sure it creates not more than one instance; in the same time it provides a global point of access to that instance. In this case the same instance can be used from everywhere, being impossible to invoke directly the constructor each time.

Well, the question is, is it safe to use a singleton class when it might be very tempting to do so? Obviously, the answer is negative.

==== Problem 1 of abusing Singleton ====
There is a general misconception about how Singletons should be used. Some people see the Singleton as a justification for global state, along the lines of "If there's a pattern for it, it must be good". Possibly, because it is true, that for having global state, it is better using Singletons, than just plainly global variables or class objects. Well no, it isn’t. Global state is considered harmful. For a number of reasons, that even Singleton-misuse won't make go away, simply because: '''Singletons are NOT intended to provide global state!'''

The Singleton is a creational pattern. It is used to enforce, that a class be instantiated only once. Create a singleton, and you have just made it possible for widely separated bits of your program to use that singleton as a secret channel to communicate with each other and, in the process, tightly couple themselves to each other. The horrible consequences of this coupling are why software engineering got out of the global variable business in the first place.

There is only one solution to this problem: Don’t do that. Properly applied, singletons are not global variables. Rather, they are meant to model things that occur
exactly once. Yes, because it occurs only once, you can use a singleton as a unique communications conduit between bits of your program. But don’t do that. Singletons are like every other pattern and programming technique—which means you can really screw things up if you abuse them. I can only repeat: Don’t do that.

=== Factory ===
Create an interface for building an object, but let subclasses decide which class to instantiate. It allows a class to defer instantiation of subclasses.
Factory pattern is one of the patterns that have being heavily abused. With as long as if --- else, go to the factory model, as long as the object involved in the creation of selective, go to the factory model. Factory pattern seems to have become the panacea to solve all.
But let us look at some of the above contrast with the factory pattern, you simple code it? Wrong! The contrary, no increase in the scalability of the code at the same time, it increased the number of types of calls, an increase of the number of categories. This is not what we want to see!

One example is there is only one object to be instantiate. There was no concept of abstraction or extended classes,just plain old ClassX & ClassXFactory.

<pre>
public class A {
public String str;
public String getStr() {
return str;
}
}// End of class

public class ChildA extends A {
public ChildA(String str) {
System.out.println("Hello "+str);
}
}// End of class

public class AFactory {
public static void main(String args[]) {
AFactory factory = new AFactory();
factory.getA(args[0]);
}

public A getA(String str) {
if(str!=NULL)
return new A(str);
else
return null;
}
}
</pre>

When to use a Factory Pattern?
The Factory patterns can be used in following cases:

1. When a class does not know which class of objects it must create.

2. A class specifies its sub-classes to specify which objects to create.

3. In programmer’s language (very raw form), you can use factory pattern where you have to create an object of any one of sub-classes depending on the data provided.

=== Visitor ===
Visitor pattern represent an operation to be performed on the elements of an object structure. In GoF's word, "It let you define a new operation changing the classes of the elements on which it operates."
However, It's also the one that GoF most worried about. It's not a "necessary evil" - but is often over used and the need for it often reveals a more fundamental flaw in your design.

Following is a classic example being that you have the intersection between two shapes, but there's an even simpler case that's often overlooked: comparing the equality of two heterogeneous objects.

<pre>
interface IShape
{
double intersectWith(Triangle t);
double intersectWith(Rectangle r);
double intersectWith(Circle c);
}
</pre>

The problem with this is that you have coupled together all of your implementations of "IShape". You've implied that whenever you wish to add a new shape to the hierarchy you will need to change all the other "Shape" implementations too.

Sometimes, this is the correct minimal design - but think it through. Does your design really mandate that you need to dispatch on two types? Are you willing to write each of the combinatorial explosion of multi-methods?

Often, by introducing another concept you can reduce the number of combinations that you're actually going to have to write:

<pre>
interface IShape
{
Area getArea();
}

class Area
{
public double intersectWith(Area otherArea);
...
}
</pre>

=== Command ===
The Command design pattern encapsulates commands (method calls) in objects allowing us to issue requests without knowing the requested operation or the requesting object. Command design pattern provides the options to queue commands, undo/redo actions and other manipulations.

There are two extremes that a programmer must avoid when using this pattern:

1. The command is just a link between the receiver and the actions that carry out the request
2. The command implements everything itself, without sending anything to the receiver.

We must always keep in mind the fact that the receiver is the one who knows how to perform the operations needed, the purpose of the command being to help the client to delegate its request quickly and to make sure the command ends up where it should.

One example is:
<pre>
class FileDeleteCommand
def initialize(path)
@path = path
end
def execute
File.delete(@path)
end
end
fdc = FileDeleteCommand.new('foo.dat')
fdc.execute
</pre>
there is nothing simpler than just getting on with it:
File.delete('foo.dat')

=== A mixed example using Singleton Factory and Command ===

The final goal of the program
<pre>
System.out.println("hello world");
</pre>

Using Singleton, Factory and Command

First we define two interfaces Subject and Observer to add Observer.
<pre>
public interface Subject {
public void attach(Observer observer);
public void detach(Observer observer);
public void notifyObservers();
}

public interface Observer {
public void update(Subject subject);
}
</pre>

Then we define two classes HelloWorldSubject and HelloWorldObserver that implements them.
<pre>
public class HelloWorldSubject implements Subject {

private ArrayList<Observer> observers;
private String str;

public HelloWorldSubject() {
super();

observers = new ArrayList<Observer>();
}

public void attach(Observer observer) {
observers.add(observer);
}

public void detach(Observer observer) {
observers.remove(observer);
}

public void notifyObservers() {
Iterator<Observer> iter = observers.iterator();

while (iter.hasNext()) {
Observer observer = iter.next();
observer.update(this);
}
}

public String getStr() {
return str;
}

public void setStr(String str) {
this.str = str;
notifyObservers();
}
}

public class HelloWorldObserver implements Observer {

public void update(Subject subject) {
HelloWorldSubject sub = (HelloWorldSubject)subject;
System.out.println(sub.getStr());
}

}
</pre>

Then we add a Command.
<pre>
public interface Command {
void execute();
}

public class HelloWorldCommand implements Command {

private HelloWorldSubject subject;

public HelloWorldCommand(Subject subject) {
super();

this.subject = (HelloWorldSubject)subject;
}

public void execute() {
subject.setStr("hello world");
}

}
</pre>

Then We add a Factory
<pre>
public interface AbstractFactory {
public Subject createSubject();
public Observer createObserver();
public Command createCommand(Subject subject);
}

public class HelloWorldFactory implements AbstractFactory {

public Subject createSubject() {
return new HelloWorldSubject();
}

public Observer createObserver() {
return new HelloWorldObserver();
}

public Command createCommand(Subject subject) {
return new HelloWorldCommand(subject);
}
}
</pre>

And a Singleton
<pre>
public class FactoryMakerSingleton {

private static FactoryMakerSingleton instance = null;
private AbstractFactory factory;

private FactoryMakerSingleton() {
factory = new HelloWorldFactory();
}

public static synchronized FactoryMakerSingleton getInstance() {
if (instance == null) {
instance = new FactoryMakerSingleton();
}

return instance;
}

public AbstractFactory getFactory() {
return factory;
}
}
</pre>

And finally the main class
<pre>
public class AbuseDesignPatterns {

public static void main(String[] args) {
AbstractFactory factory = FactoryMakerSingleton.getInstance().getFactory();

Subject subject = factory.createSubject();
subject.attach(factory.createObserver());

Command command = factory.createCommand(subject);

command.execute();
}

}

And the output is: Hello World
</pre>

= Conclusion =
= Reference =

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-28T03:29:35Z

Yliu63: /* A mixed example using Singleton Factory and Command */

= Introduction =
The purpose of the wiki is to introduce and show some example about pattern fragility. The contents include definition of pattern fragility and what does the concept cover. We also give some examples of mistakes in code that spoil the benefits of design patterns.

= Design Patterns =
A design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be transformed directly into source or machine code. It is a description or template for how to solve a problem that can be used in many different situations. Patterns are formalized best practices that the programmer must implement themselves in the application. Object-oriented design patterns typically show relationships and interactions between classes or objects, without specifying the final application classes or objects that are involved. Many patterns imply object-orientation or more generally mutable state, and so may not be as applicable in functional programming languages, in which data is immutable or treated as such.
== Why Design Patterns ==
A design pattern is a pattern—a way to pursue an intent—that uses classes and their methods in an object-oriented language. Developers often start thinking about design after learning a programming language and writing code for a while. You might notice that someone else’s code seems simpler and works better than yours does, and you might wonder how that developer achieves such simplicity. Design patterns are a level up from code and typically show how to achieve a goal using a few classes. A pattern represents an idea, not a particular implementation.

== Categorization of Patterns ==
{| class="wikitable"
|-
! Intent !! Patterns
|-
| Interfaces || ADAPTER, FACADE, COMPOSITE, BRIDGE
|-
| Responsibility || SINGLETON, OBSERVER, MEDIATOR, PROXY, CHAIN OF RESPONSIBILITY, FLYWEIGHT
|-
| Construction || BUILDER, FACTORY METHOD, ABSTRACT FACTORY, PROTOTYPE, MEMENTO
|-
| Operations|| TEMPLATE METHOD, STATE, STRATEGY, COMMAND, INTERPRETER
|-
| Extensions || DECORATOR, ITERATOR, VISITOR
|}

== Benefits of Design Patterns ==
Design patterns provide a way of encapsulating the experience of software developers in a form that can be communicated to other developers. They provide a higher level of abstraction than single classes and objects thus providing bigger building blocks in the construction of software designs.

The main benefits of design patterns are:

*They encapsulate and codify design experience.
*Provide a common vocabulary for software designers to use when communicating with their peers.
*Enhance maintainability of software systems whose designs are documented with patterns.
*Provide robustness to the design by copying or imitating proven design techniques.
*Reuse at the design level.

At first glance some of these benefits may not seem very powerful, but upon further inspection maybe we can gain new insight into the true nature of their value. Let us just consider the fact that we have given a design pattern a common name. We can now communicate an entire design principle or concept with other software developers by just using the simple name of the pattern. In one fell swoop we have drastically reduced the effort and time needed for a developer to discuss a concept with another developer. Taken one step further we can discuss the patterns and their interactions in the system and illustrate the system architecture in few sentences. Grouping design concepts with common names facilitates communication among developers and raises the conversation to a higher level of abstraction.

= Pattern Fragility =
== Symptoms of Rotting Design ==
There are four primary symptoms that tell us that our designs are rotting. They are not orthogonal, but are related to each other in ways that will become obvious.

The four symptoms are:
*Rigidity -- the tendency for software to be difficult to change, even in simple ways.
*Fragility -- the tendency of the software to break in many places every time it is changed.
*Immobility -- the inability to reuse software from other projects or from parts of the same project.
*Viscosity -- viscosity comes in two forms: viscosity of the design, and viscosity of the environment.

In following passage of this wiki page, we will discuss over 'Fragility' with some examples.

== Definition of Pattern Fragility ==
Fragility is the tendency of the
software to break in many places every time it is changed. Often the breakage occurs
in areas that have no conceptual relationship with the area that was changed. Such
errors fill the hearts of managers with foreboding. Every time they authorize a fix,
they fear that the software will break in some unexpected way.
As the fragility becomes worse, the probability of breakage increases with time,
asymptotically approaching 1. Such software is impossible to maintain. Every fix
makes it worse, introducing more problems than are solved.
Such software causes managers and customers to suspect that the developers have lost
control of their software. Distrust reigns, and credibility is lost.

== Examples ==
=== Singleton -- the most overused pattern ===

Sometimes it's important to have only one instance for a class. For example, in a system there should be only one window manager (or only a file system). Usually singletons are used for centralized management of internal or external resources and they provide a global point of access to themselves. The primary purpose of the singleton is to guarantee that at anytime there is only one instance for a given class and provide a global reference to it.

The singleton pattern is one of the simplest design patterns: it involves only one class which is responsible to instantiate itself, to make sure it creates not more than one instance; in the same time it provides a global point of access to that instance. In this case the same instance can be used from everywhere, being impossible to invoke directly the constructor each time.

Well, the question is, is it safe to use a singleton class when it might be very tempting to do so? Obviously, the answer is negative.

==== Problem 1 of abusing Singleton ====
There is a general misconception about how Singletons should be used. Some people see the Singleton as a justification for global state, along the lines of "If there's a pattern for it, it must be good". Possibly, because it is true, that for having global state, it is better using Singletons, than just plainly global variables or class objects. Well no, it isn’t. Global state is considered harmful. For a number of reasons, that even Singleton-misuse won't make go away, simply because: '''Singletons are NOT intended to provide global state!'''

The Singleton is a creational pattern. It is used to enforce, that a class be instantiated only once. Create a singleton, and you have just made it possible for widely separated bits of your program to use that singleton as a secret channel to communicate with each other and, in the process, tightly couple themselves to each other. The horrible consequences of this coupling are why software engineering got out of the global variable business in the first place.

There is only one solution to this problem: Don’t do that. Properly applied, singletons are not global variables. Rather, they are meant to model things that occur
exactly once. Yes, because it occurs only once, you can use a singleton as a unique communications conduit between bits of your program. But don’t do that. Singletons are like every other pattern and programming technique—which means you can really screw things up if you abuse them. I can only repeat: Don’t do that.

=== Factory ===
Create an interface for building an object, but let subclasses decide which class to instantiate. It allows a class to defer instantiation of subclasses.
Factory pattern is one of the patterns that have being heavily abused. With as long as if --- else, go to the factory model, as long as the object involved in the creation of selective, go to the factory model. Factory pattern seems to have become the panacea to solve all.
But let us look at some of the above contrast with the factory pattern, you simple code it? Wrong! The contrary, no increase in the scalability of the code at the same time, it increased the number of types of calls, an increase of the number of categories. This is not what we want to see!

One example is there is only one object to be instantiate. There was no concept of abstraction or extended classes,just plain old ClassX & ClassXFactory.

<pre>
public class A {
public String str;
public String getStr() {
return str;
}
}// End of class

public class ChildA extends A {
public ChildA(String str) {
System.out.println("Hello "+str);
}
}// End of class

public class AFactory {
public static void main(String args[]) {
AFactory factory = new AFactory();
factory.getA(args[0]);
}

public A getA(String str) {
if(str!=NULL)
return new A(str);
else
return null;
}
}
</pre>

When to use a Factory Pattern?
The Factory patterns can be used in following cases:

1. When a class does not know which class of objects it must create.

2. A class specifies its sub-classes to specify which objects to create.

3. In programmer’s language (very raw form), you can use factory pattern where you have to create an object of any one of sub-classes depending on the data provided.

=== Visitor ===
Visitor pattern represent an operation to be performed on the elements of an object structure. In GoF's word, "It let you define a new operation changing the classes of the elements on which it operates."
However, It's also the one that GoF most worried about. It's not a "necessary evil" - but is often over used and the need for it often reveals a more fundamental flaw in your design.

Following is a classic example being that you have the intersection between two shapes, but there's an even simpler case that's often overlooked: comparing the equality of two heterogeneous objects.

<pre>
interface IShape
{
double intersectWith(Triangle t);
double intersectWith(Rectangle r);
double intersectWith(Circle c);
}
</pre>

The problem with this is that you have coupled together all of your implementations of "IShape". You've implied that whenever you wish to add a new shape to the hierarchy you will need to change all the other "Shape" implementations too.

Sometimes, this is the correct minimal design - but think it through. Does your design really mandate that you need to dispatch on two types? Are you willing to write each of the combinatorial explosion of multi-methods?

Often, by introducing another concept you can reduce the number of combinations that you're actually going to have to write:

<pre>
interface IShape
{
Area getArea();
}

class Area
{
public double intersectWith(Area otherArea);
...
}
</pre>

=== Command ===
The Command design pattern encapsulates commands (method calls) in objects allowing us to issue requests without knowing the requested operation or the requesting object. Command design pattern provides the options to queue commands, undo/redo actions and other manipulations.

There are two extremes that a programmer must avoid when using this pattern:

1. The command is just a link between the receiver and the actions that carry out the request
2. The command implements everything itself, without sending anything to the receiver.

We must always keep in mind the fact that the receiver is the one who knows how to perform the operations needed, the purpose of the command being to help the client to delegate its request quickly and to make sure the command ends up where it should.

One example is:
<pre>
class FileDeleteCommand
def initialize(path)
@path = path
end
def execute
File.delete(@path)
end
end
fdc = FileDeleteCommand.new('foo.dat')
fdc.execute
</pre>
there is nothing simpler than just getting on with it:
File.delete('foo.dat')

=== A mixed example using Singleton Factory and Command ===

The final goal of the program
<pre>
System.out.println("hello world");
</pre>

Using Singleton, Factory and Command

First we define two interfaces Subject and Observer to add Observer.
<pre>
public interface Subject {
public void attach(Observer observer);
public void detach(Observer observer);
public void notifyObservers();
}

public interface Observer {
public void update(Subject subject);
}
</pre>

Then we define two classes HelloWorldSubject and HelloWorldObserver that implements them.
<pre>
public class HelloWorldSubject implements Subject {

private ArrayList<Observer> observers;
private String str;

public HelloWorldSubject() {
super();

observers = new ArrayList<Observer>();
}

public void attach(Observer observer) {
observers.add(observer);
}

public void detach(Observer observer) {
observers.remove(observer);
}

public void notifyObservers() {
Iterator<Observer> iter = observers.iterator();

while (iter.hasNext()) {
Observer observer = iter.next();
observer.update(this);
}
}

public String getStr() {
return str;
}

public void setStr(String str) {
this.str = str;
notifyObservers();
}
}

public class HelloWorldObserver implements Observer {

public void update(Subject subject) {
HelloWorldSubject sub = (HelloWorldSubject)subject;
System.out.println(sub.getStr());
}

}
</pre>

Then we add a Command.
<pre>
public interface Command {
void execute();
}

public class HelloWorldCommand implements Command {

private HelloWorldSubject subject;

public HelloWorldCommand(Subject subject) {
super();

this.subject = (HelloWorldSubject)subject;
}

public void execute() {
subject.setStr("hello world");
}

}
</pre>

Then We add a Factory
<pre>
public interface AbstractFactory {
public Subject createSubject();
public Observer createObserver();
public Command createCommand(Subject subject);
}

public class HelloWorldFactory implements AbstractFactory {

public Subject createSubject() {
return new HelloWorldSubject();
}

public Observer createObserver() {
return new HelloWorldObserver();
}

public Command createCommand(Subject subject) {
return new HelloWorldCommand(subject);
}
}
</pre>

And finally a Singleton
<pre>
public class FactoryMakerSingleton {

private static FactoryMakerSingleton instance = null;
private AbstractFactory factory;

private FactoryMakerSingleton() {
factory = new HelloWorldFactory();
}

public static synchronized FactoryMakerSingleton getInstance() {
if (instance == null) {
instance = new FactoryMakerSingleton();
}

return instance;
}

public AbstractFactory getFactory() {
return factory;
}
}
</pre>

And the main class
<pre>
public class AbuseDesignPatterns {

public static void main(String[] args) {
AbstractFactory factory = FactoryMakerSingleton.getInstance().getFactory();

Subject subject = factory.createSubject();
subject.attach(factory.createObserver());

Command command = factory.createCommand(subject);

command.execute();
}

}

And the output is: Hello World
</pre>

= Conclusion =
= Reference =

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-28T03:27:37Z

Yliu63: /* A mixed example using Singleton Factory and Command */

= Introduction =
The purpose of the wiki is to introduce and show some example about pattern fragility. The contents include definition of pattern fragility and what does the concept cover. We also give some examples of mistakes in code that spoil the benefits of design patterns.

= Design Patterns =
A design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be transformed directly into source or machine code. It is a description or template for how to solve a problem that can be used in many different situations. Patterns are formalized best practices that the programmer must implement themselves in the application. Object-oriented design patterns typically show relationships and interactions between classes or objects, without specifying the final application classes or objects that are involved. Many patterns imply object-orientation or more generally mutable state, and so may not be as applicable in functional programming languages, in which data is immutable or treated as such.
== Why Design Patterns ==
A design pattern is a pattern—a way to pursue an intent—that uses classes and their methods in an object-oriented language. Developers often start thinking about design after learning a programming language and writing code for a while. You might notice that someone else’s code seems simpler and works better than yours does, and you might wonder how that developer achieves such simplicity. Design patterns are a level up from code and typically show how to achieve a goal using a few classes. A pattern represents an idea, not a particular implementation.

== Categorization of Patterns ==
{| class="wikitable"
|-
! Intent !! Patterns
|-
| Interfaces || ADAPTER, FACADE, COMPOSITE, BRIDGE
|-
| Responsibility || SINGLETON, OBSERVER, MEDIATOR, PROXY, CHAIN OF RESPONSIBILITY, FLYWEIGHT
|-
| Construction || BUILDER, FACTORY METHOD, ABSTRACT FACTORY, PROTOTYPE, MEMENTO
|-
| Operations|| TEMPLATE METHOD, STATE, STRATEGY, COMMAND, INTERPRETER
|-
| Extensions || DECORATOR, ITERATOR, VISITOR
|}

== Benefits of Design Patterns ==
Design patterns provide a way of encapsulating the experience of software developers in a form that can be communicated to other developers. They provide a higher level of abstraction than single classes and objects thus providing bigger building blocks in the construction of software designs.

The main benefits of design patterns are:

*They encapsulate and codify design experience.
*Provide a common vocabulary for software designers to use when communicating with their peers.
*Enhance maintainability of software systems whose designs are documented with patterns.
*Provide robustness to the design by copying or imitating proven design techniques.
*Reuse at the design level.

At first glance some of these benefits may not seem very powerful, but upon further inspection maybe we can gain new insight into the true nature of their value. Let us just consider the fact that we have given a design pattern a common name. We can now communicate an entire design principle or concept with other software developers by just using the simple name of the pattern. In one fell swoop we have drastically reduced the effort and time needed for a developer to discuss a concept with another developer. Taken one step further we can discuss the patterns and their interactions in the system and illustrate the system architecture in few sentences. Grouping design concepts with common names facilitates communication among developers and raises the conversation to a higher level of abstraction.

= Pattern Fragility =
== Symptoms of Rotting Design ==
There are four primary symptoms that tell us that our designs are rotting. They are not orthogonal, but are related to each other in ways that will become obvious.

The four symptoms are:
*Rigidity -- the tendency for software to be difficult to change, even in simple ways.
*Fragility -- the tendency of the software to break in many places every time it is changed.
*Immobility -- the inability to reuse software from other projects or from parts of the same project.
*Viscosity -- viscosity comes in two forms: viscosity of the design, and viscosity of the environment.

In following passage of this wiki page, we will discuss over 'Fragility' with some examples.

== Definition of Pattern Fragility ==
Fragility is the tendency of the
software to break in many places every time it is changed. Often the breakage occurs
in areas that have no conceptual relationship with the area that was changed. Such
errors fill the hearts of managers with foreboding. Every time they authorize a fix,
they fear that the software will break in some unexpected way.
As the fragility becomes worse, the probability of breakage increases with time,
asymptotically approaching 1. Such software is impossible to maintain. Every fix
makes it worse, introducing more problems than are solved.
Such software causes managers and customers to suspect that the developers have lost
control of their software. Distrust reigns, and credibility is lost.

== Examples ==
=== Singleton -- the most overused pattern ===

Sometimes it's important to have only one instance for a class. For example, in a system there should be only one window manager (or only a file system). Usually singletons are used for centralized management of internal or external resources and they provide a global point of access to themselves. The primary purpose of the singleton is to guarantee that at anytime there is only one instance for a given class and provide a global reference to it.

The singleton pattern is one of the simplest design patterns: it involves only one class which is responsible to instantiate itself, to make sure it creates not more than one instance; in the same time it provides a global point of access to that instance. In this case the same instance can be used from everywhere, being impossible to invoke directly the constructor each time.

Well, the question is, is it safe to use a singleton class when it might be very tempting to do so? Obviously, the answer is negative.

==== Problem 1 of abusing Singleton ====
There is a general misconception about how Singletons should be used. Some people see the Singleton as a justification for global state, along the lines of "If there's a pattern for it, it must be good". Possibly, because it is true, that for having global state, it is better using Singletons, than just plainly global variables or class objects. Well no, it isn’t. Global state is considered harmful. For a number of reasons, that even Singleton-misuse won't make go away, simply because: '''Singletons are NOT intended to provide global state!'''

The Singleton is a creational pattern. It is used to enforce, that a class be instantiated only once. Create a singleton, and you have just made it possible for widely separated bits of your program to use that singleton as a secret channel to communicate with each other and, in the process, tightly couple themselves to each other. The horrible consequences of this coupling are why software engineering got out of the global variable business in the first place.

There is only one solution to this problem: Don’t do that. Properly applied, singletons are not global variables. Rather, they are meant to model things that occur
exactly once. Yes, because it occurs only once, you can use a singleton as a unique communications conduit between bits of your program. But don’t do that. Singletons are like every other pattern and programming technique—which means you can really screw things up if you abuse them. I can only repeat: Don’t do that.

=== Factory ===
Create an interface for building an object, but let subclasses decide which class to instantiate. It allows a class to defer instantiation of subclasses.
Factory pattern is one of the patterns that have being heavily abused. With as long as if --- else, go to the factory model, as long as the object involved in the creation of selective, go to the factory model. Factory pattern seems to have become the panacea to solve all.
But let us look at some of the above contrast with the factory pattern, you simple code it? Wrong! The contrary, no increase in the scalability of the code at the same time, it increased the number of types of calls, an increase of the number of categories. This is not what we want to see!

One example is there is only one object to be instantiate. There was no concept of abstraction or extended classes,just plain old ClassX & ClassXFactory.

<pre>
public class A {
public String str;
public String getStr() {
return str;
}
}// End of class

public class ChildA extends A {
public ChildA(String str) {
System.out.println("Hello "+str);
}
}// End of class

public class AFactory {
public static void main(String args[]) {
AFactory factory = new AFactory();
factory.getA(args[0]);
}

public A getA(String str) {
if(str!=NULL)
return new A(str);
else
return null;
}
}
</pre>

When to use a Factory Pattern?
The Factory patterns can be used in following cases:

1. When a class does not know which class of objects it must create.

2. A class specifies its sub-classes to specify which objects to create.

3. In programmer’s language (very raw form), you can use factory pattern where you have to create an object of any one of sub-classes depending on the data provided.

=== Visitor ===
Visitor pattern represent an operation to be performed on the elements of an object structure. In GoF's word, "It let you define a new operation changing the classes of the elements on which it operates."
However, It's also the one that GoF most worried about. It's not a "necessary evil" - but is often over used and the need for it often reveals a more fundamental flaw in your design.

Following is a classic example being that you have the intersection between two shapes, but there's an even simpler case that's often overlooked: comparing the equality of two heterogeneous objects.

<pre>
interface IShape
{
double intersectWith(Triangle t);
double intersectWith(Rectangle r);
double intersectWith(Circle c);
}
</pre>

The problem with this is that you have coupled together all of your implementations of "IShape". You've implied that whenever you wish to add a new shape to the hierarchy you will need to change all the other "Shape" implementations too.

Sometimes, this is the correct minimal design - but think it through. Does your design really mandate that you need to dispatch on two types? Are you willing to write each of the combinatorial explosion of multi-methods?

Often, by introducing another concept you can reduce the number of combinations that you're actually going to have to write:

<pre>
interface IShape
{
Area getArea();
}

class Area
{
public double intersectWith(Area otherArea);
...
}
</pre>

=== Command ===
The Command design pattern encapsulates commands (method calls) in objects allowing us to issue requests without knowing the requested operation or the requesting object. Command design pattern provides the options to queue commands, undo/redo actions and other manipulations.

There are two extremes that a programmer must avoid when using this pattern:

1. The command is just a link between the receiver and the actions that carry out the request
2. The command implements everything itself, without sending anything to the receiver.

We must always keep in mind the fact that the receiver is the one who knows how to perform the operations needed, the purpose of the command being to help the client to delegate its request quickly and to make sure the command ends up where it should.

One example is:
<pre>
class FileDeleteCommand
def initialize(path)
@path = path
end
def execute
File.delete(@path)
end
end
fdc = FileDeleteCommand.new('foo.dat')
fdc.execute
</pre>
there is nothing simpler than just getting on with it:
File.delete('foo.dat')

=== A mixed example using Singleton Factory and Command ===

The final goal of the program
<pre>
System.out.println("hello world");
</pre>

After using Singleton, Factory and Command
<pre>
public interface Subject {
public void attach(Observer observer);
public void detach(Observer observer);
public void notifyObservers();
}

public interface Observer {
public void update(Subject subject);
}

public class HelloWorldSubject implements Subject {

private ArrayList<Observer> observers;
private String str;

public HelloWorldSubject() {
super();

observers = new ArrayList<Observer>();
}

public void attach(Observer observer) {
observers.add(observer);
}

public void detach(Observer observer) {
observers.remove(observer);
}

public void notifyObservers() {
Iterator<Observer> iter = observers.iterator();

while (iter.hasNext()) {
Observer observer = iter.next();
observer.update(this);
}
}

public String getStr() {
return str;
}

public void setStr(String str) {
this.str = str;
notifyObservers();
}
}

public class HelloWorldObserver implements Observer {

public void update(Subject subject) {
HelloWorldSubject sub = (HelloWorldSubject)subject;
System.out.println(sub.getStr());
}

}
</pre>

Then we add a Command.
<pre>
public interface Command {
void execute();
}

public class HelloWorldCommand implements Command {

private HelloWorldSubject subject;

public HelloWorldCommand(Subject subject) {
super();

this.subject = (HelloWorldSubject)subject;
}

public void execute() {
subject.setStr("hello world");
}

}
</pre>

Then We add a Factory
<pre>
public interface AbstractFactory {
public Subject createSubject();
public Observer createObserver();
public Command createCommand(Subject subject);
}

public class HelloWorldFactory implements AbstractFactory {

public Subject createSubject() {
return new HelloWorldSubject();
}

public Observer createObserver() {
return new HelloWorldObserver();
}

public Command createCommand(Subject subject) {
return new HelloWorldCommand(subject);
}
}
</pre>

And finally a Singleton
<pre>
public class FactoryMakerSingleton {

private static FactoryMakerSingleton instance = null;
private AbstractFactory factory;

private FactoryMakerSingleton() {
factory = new HelloWorldFactory();
}

public static synchronized FactoryMakerSingleton getInstance() {
if (instance == null) {
instance = new FactoryMakerSingleton();
}

return instance;
}

public AbstractFactory getFactory() {
return factory;
}
}
</pre>

And the main class
<pre>
public class AbuseDesignPatterns {

public static void main(String[] args) {
AbstractFactory factory = FactoryMakerSingleton.getInstance().getFactory();

Subject subject = factory.createSubject();
subject.attach(factory.createObserver());

Command command = factory.createCommand(subject);

command.execute();
}

}

And the output is: Hello World
</pre>

= Conclusion =
= Reference =

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-28T03:23:54Z

Yliu63: /* Command */

= Introduction =
The purpose of the wiki is to introduce and show some example about pattern fragility. The contents include definition of pattern fragility and what does the concept cover. We also give some examples of mistakes in code that spoil the benefits of design patterns.

= Design Patterns =
A design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be transformed directly into source or machine code. It is a description or template for how to solve a problem that can be used in many different situations. Patterns are formalized best practices that the programmer must implement themselves in the application. Object-oriented design patterns typically show relationships and interactions between classes or objects, without specifying the final application classes or objects that are involved. Many patterns imply object-orientation or more generally mutable state, and so may not be as applicable in functional programming languages, in which data is immutable or treated as such.
== Why Design Patterns ==
A design pattern is a pattern—a way to pursue an intent—that uses classes and their methods in an object-oriented language. Developers often start thinking about design after learning a programming language and writing code for a while. You might notice that someone else’s code seems simpler and works better than yours does, and you might wonder how that developer achieves such simplicity. Design patterns are a level up from code and typically show how to achieve a goal using a few classes. A pattern represents an idea, not a particular implementation.

== Categorization of Patterns ==
{| class="wikitable"
|-
! Intent !! Patterns
|-
| Interfaces || ADAPTER, FACADE, COMPOSITE, BRIDGE
|-
| Responsibility || SINGLETON, OBSERVER, MEDIATOR, PROXY, CHAIN OF RESPONSIBILITY, FLYWEIGHT
|-
| Construction || BUILDER, FACTORY METHOD, ABSTRACT FACTORY, PROTOTYPE, MEMENTO
|-
| Operations|| TEMPLATE METHOD, STATE, STRATEGY, COMMAND, INTERPRETER
|-
| Extensions || DECORATOR, ITERATOR, VISITOR
|}

== Benefits of Design Patterns ==
Design patterns provide a way of encapsulating the experience of software developers in a form that can be communicated to other developers. They provide a higher level of abstraction than single classes and objects thus providing bigger building blocks in the construction of software designs.

The main benefits of design patterns are:

*They encapsulate and codify design experience.
*Provide a common vocabulary for software designers to use when communicating with their peers.
*Enhance maintainability of software systems whose designs are documented with patterns.
*Provide robustness to the design by copying or imitating proven design techniques.
*Reuse at the design level.

At first glance some of these benefits may not seem very powerful, but upon further inspection maybe we can gain new insight into the true nature of their value. Let us just consider the fact that we have given a design pattern a common name. We can now communicate an entire design principle or concept with other software developers by just using the simple name of the pattern. In one fell swoop we have drastically reduced the effort and time needed for a developer to discuss a concept with another developer. Taken one step further we can discuss the patterns and their interactions in the system and illustrate the system architecture in few sentences. Grouping design concepts with common names facilitates communication among developers and raises the conversation to a higher level of abstraction.

= Pattern Fragility =
== Symptoms of Rotting Design ==
There are four primary symptoms that tell us that our designs are rotting. They are not orthogonal, but are related to each other in ways that will become obvious.

The four symptoms are:
*Rigidity -- the tendency for software to be difficult to change, even in simple ways.
*Fragility -- the tendency of the software to break in many places every time it is changed.
*Immobility -- the inability to reuse software from other projects or from parts of the same project.
*Viscosity -- viscosity comes in two forms: viscosity of the design, and viscosity of the environment.

In following passage of this wiki page, we will discuss over 'Fragility' with some examples.

== Definition of Pattern Fragility ==
Fragility is the tendency of the
software to break in many places every time it is changed. Often the breakage occurs
in areas that have no conceptual relationship with the area that was changed. Such
errors fill the hearts of managers with foreboding. Every time they authorize a fix,
they fear that the software will break in some unexpected way.
As the fragility becomes worse, the probability of breakage increases with time,
asymptotically approaching 1. Such software is impossible to maintain. Every fix
makes it worse, introducing more problems than are solved.
Such software causes managers and customers to suspect that the developers have lost
control of their software. Distrust reigns, and credibility is lost.

== Examples ==
=== Singleton -- the most overused pattern ===

Sometimes it's important to have only one instance for a class. For example, in a system there should be only one window manager (or only a file system). Usually singletons are used for centralized management of internal or external resources and they provide a global point of access to themselves. The primary purpose of the singleton is to guarantee that at anytime there is only one instance for a given class and provide a global reference to it.

The singleton pattern is one of the simplest design patterns: it involves only one class which is responsible to instantiate itself, to make sure it creates not more than one instance; in the same time it provides a global point of access to that instance. In this case the same instance can be used from everywhere, being impossible to invoke directly the constructor each time.

Well, the question is, is it safe to use a singleton class when it might be very tempting to do so? Obviously, the answer is negative.

==== Problem 1 ====
There is a general misconception about how Singletons should be used. Some people see the Singleton as a justification for global state, along the lines of "If there's a pattern for it, it must be good". Possibly, because it is true, that for having global state, it is better using Singletons, than just plainly global variables or class objects. Well no, it isn’t. Global state is considered harmful. For a number of reasons, that even Singleton-misuse won't make go away, simply because: '''Singletons are NOT intended to provide global state!'''

The Singleton is a creational pattern. It is used to enforce, that a class be instantiated only once. What it basically does is, to give control over instantiation back to the programmer. This is what you sometimes need in languages with classical constructors (Java, C++ and such).

=== Factory ===
Create an interface for building an object, but let subclasses decide which class to instantiate. It allows a class to defer instantiation of subclasses.
Factory pattern is one of the patterns that have being heavily abused. With as long as if --- else, go to the factory model, as long as the object involved in the creation of selective, go to the factory model. Factory pattern seems to have become the panacea to solve all.
But let us look at some of the above contrast with the factory pattern, you simple code it? Wrong! The contrary, no increase in the scalability of the code at the same time, it increased the number of types of calls, an increase of the number of categories. This is not what we want to see!

One example is there is only one object to be instantiate. There was no concept of abstraction or extended classes,just plain old ClassX & ClassXFactory.

<pre>
public class A {
public String str;
public String getStr() {
return str;
}
}// End of class

public class ChildA extends A {
public ChildA(String str) {
System.out.println("Hello "+str);
}
}// End of class

public class AFactory {
public static void main(String args[]) {
AFactory factory = new AFactory();
factory.getA(args[0]);
}

public A getA(String str) {
if(str!=NULL)
return new A(str);
else
return null;
}
}
</pre>

When to use a Factory Pattern?
The Factory patterns can be used in following cases:

1. When a class does not know which class of objects it must create.

2. A class specifies its sub-classes to specify which objects to create.

3. In programmer’s language (very raw form), you can use factory pattern where you have to create an object of any one of sub-classes depending on the data provided.

=== Visitor ===
Visitor pattern represent an operation to be performed on the elements of an object structure. In GoF's word, "It let you define a new operation changing the classes of the elements on which it operates."
However, It's also the one that GoF most worried about. It's not a "necessary evil" - but is often over used and the need for it often reveals a more fundamental flaw in your design.

Following is a classic example being that you have the intersection between two shapes, but there's an even simpler case that's often overlooked: comparing the equality of two heterogeneous objects.

<pre>
interface IShape
{
double intersectWith(Triangle t);
double intersectWith(Rectangle r);
double intersectWith(Circle c);
}
</pre>

The problem with this is that you have coupled together all of your implementations of "IShape". You've implied that whenever you wish to add a new shape to the hierarchy you will need to change all the other "Shape" implementations too.

Sometimes, this is the correct minimal design - but think it through. Does your design really mandate that you need to dispatch on two types? Are you willing to write each of the combinatorial explosion of multi-methods?

Often, by introducing another concept you can reduce the number of combinations that you're actually going to have to write:

<pre>
interface IShape
{
Area getArea();
}

class Area
{
public double intersectWith(Area otherArea);
...
}
</pre>

=== Command ===
The Command design pattern encapsulates commands (method calls) in objects allowing us to issue requests without knowing the requested operation or the requesting object. Command design pattern provides the options to queue commands, undo/redo actions and other manipulations.

There are two extremes that a programmer must avoid when using this pattern:

1. The command is just a link between the receiver and the actions that carry out the request
2. The command implements everything itself, without sending anything to the receiver.

We must always keep in mind the fact that the receiver is the one who knows how to perform the operations needed, the purpose of the command being to help the client to delegate its request quickly and to make sure the command ends up where it should.

One example is:
<pre>
class FileDeleteCommand
def initialize(path)
@path = path
end
def execute
File.delete(@path)
end
end
fdc = FileDeleteCommand.new('foo.dat')
fdc.execute
</pre>
there is nothing simpler than just getting on with it:
File.delete('foo.dat')

=== A mixed example using Singleton Factory and Command ===

The final goal of the program
<pre>
System.out.println("hello world");
</pre>

After using Singleton, Factory and Command
<pre>
public interface Subject {
public void attach(Observer observer);
public void detach(Observer observer);
public void notifyObservers();
}

public interface Observer {
public void update(Subject subject);
}

public class HelloWorldSubject implements Subject {

private ArrayList<Observer> observers;
private String str;

public HelloWorldSubject() {
super();

observers = new ArrayList<Observer>();
}

public void attach(Observer observer) {
observers.add(observer);
}

public void detach(Observer observer) {
observers.remove(observer);
}

public void notifyObservers() {
Iterator<Observer> iter = observers.iterator();

while (iter.hasNext()) {
Observer observer = iter.next();
observer.update(this);
}
}

public String getStr() {
return str;
}

public void setStr(String str) {
this.str = str;
notifyObservers();
}
}

public class HelloWorldObserver implements Observer {

public void update(Subject subject) {
HelloWorldSubject sub = (HelloWorldSubject)subject;
System.out.println(sub.getStr());
}

}

public interface Command {
void execute();
}

public class HelloWorldCommand implements Command {

private HelloWorldSubject subject;

public HelloWorldCommand(Subject subject) {
super();

this.subject = (HelloWorldSubject)subject;
}

public void execute() {
subject.setStr("hello world");
}

}

Then We add a Factory
public interface AbstractFactory {
public Subject createSubject();
public Observer createObserver();
public Command createCommand(Subject subject);
}

public class HelloWorldFactory implements AbstractFactory {

public Subject createSubject() {
return new HelloWorldSubject();
}

public Observer createObserver() {
return new HelloWorldObserver();
}

public Command createCommand(Subject subject) {
return new HelloWorldCommand(subject);
}
}

And finally a Singleton
public class FactoryMakerSingleton {

private static FactoryMakerSingleton instance = null;
private AbstractFactory factory;

private FactoryMakerSingleton() {
factory = new HelloWorldFactory();
}

public static synchronized FactoryMakerSingleton getInstance() {
if (instance == null) {
instance = new FactoryMakerSingleton();
}

return instance;
}

public AbstractFactory getFactory() {
return factory;
}
}

And the main class
public class AbuseDesignPatterns {

public static void main(String[] args) {
AbstractFactory factory = FactoryMakerSingleton.getInstance().getFactory();

Subject subject = factory.createSubject();
subject.attach(factory.createObserver());

Command command = factory.createCommand(subject);

command.execute();
}

}

And the output is: Hello World
</pre>

= Conclusion =
= Reference =

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-28T03:09:08Z

Yliu63: /* Visitor */

= Introduction =
The purpose of the wiki is to introduce and show some example about pattern fragility. The contents include definition of pattern fragility and what does the concept cover. We also give some examples of mistakes in code that spoil the benefits of design patterns.

= Design Patterns =
A design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be transformed directly into source or machine code. It is a description or template for how to solve a problem that can be used in many different situations. Patterns are formalized best practices that the programmer must implement themselves in the application. Object-oriented design patterns typically show relationships and interactions between classes or objects, without specifying the final application classes or objects that are involved. Many patterns imply object-orientation or more generally mutable state, and so may not be as applicable in functional programming languages, in which data is immutable or treated as such.
== Why Design Patterns ==
A design pattern is a pattern—a way to pursue an intent—that uses classes and their methods in an object-oriented language. Developers often start thinking about design after learning a programming language and writing code for a while. You might notice that someone else’s code seems simpler and works better than yours does, and you might wonder how that developer achieves such simplicity. Design patterns are a level up from code and typically show how to achieve a goal using a few classes. A pattern represents an idea, not a particular implementation.

== Categorization of Patterns ==
{| class="wikitable"
|-
! Intent !! Patterns
|-
| Interfaces || ADAPTER, FACADE, COMPOSITE, BRIDGE
|-
| Responsibility || SINGLETON, OBSERVER, MEDIATOR, PROXY, CHAIN OF RESPONSIBILITY, FLYWEIGHT
|-
| Construction || BUILDER, FACTORY METHOD, ABSTRACT FACTORY, PROTOTYPE, MEMENTO
|-
| Operations|| TEMPLATE METHOD, STATE, STRATEGY, COMMAND, INTERPRETER
|-
| Extensions || DECORATOR, ITERATOR, VISITOR
|}

== Benefits of Design Patterns ==
Design patterns provide a way of encapsulating the experience of software developers in a form that can be communicated to other developers. They provide a higher level of abstraction than single classes and objects thus providing bigger building blocks in the construction of software designs.

The main benefits of design patterns are:

*They encapsulate and codify design experience.
*Provide a common vocabulary for software designers to use when communicating with their peers.
*Enhance maintainability of software systems whose designs are documented with patterns.
*Provide robustness to the design by copying or imitating proven design techniques.
*Reuse at the design level.

At first glance some of these benefits may not seem very powerful, but upon further inspection maybe we can gain new insight into the true nature of their value. Let us just consider the fact that we have given a design pattern a common name. We can now communicate an entire design principle or concept with other software developers by just using the simple name of the pattern. In one fell swoop we have drastically reduced the effort and time needed for a developer to discuss a concept with another developer. Taken one step further we can discuss the patterns and their interactions in the system and illustrate the system architecture in few sentences. Grouping design concepts with common names facilitates communication among developers and raises the conversation to a higher level of abstraction.

= Pattern Fragility =
== Symptoms of Rotting Design ==
There are four primary symptoms that tell us that our designs are rotting. They are not orthogonal, but are related to each other in ways that will become obvious.

The four symptoms are:
*Rigidity -- the tendency for software to be difficult to change, even in simple ways.
*Fragility -- the tendency of the software to break in many places every time it is changed.
*Immobility -- the inability to reuse software from other projects or from parts of the same project.
*Viscosity -- viscosity comes in two forms: viscosity of the design, and viscosity of the environment.

In following passage of this wiki page, we will discuss over 'Fragility' with some examples.

== Definition of Pattern Fragility ==
Fragility is the tendency of the
software to break in many places every time it is changed. Often the breakage occurs
in areas that have no conceptual relationship with the area that was changed. Such
errors fill the hearts of managers with foreboding. Every time they authorize a fix,
they fear that the software will break in some unexpected way.
As the fragility becomes worse, the probability of breakage increases with time,
asymptotically approaching 1. Such software is impossible to maintain. Every fix
makes it worse, introducing more problems than are solved.
Such software causes managers and customers to suspect that the developers have lost
control of their software. Distrust reigns, and credibility is lost.

== Examples ==
=== Singleton -- the most overused pattern ===

Sometimes it's important to have only one instance for a class. For example, in a system there should be only one window manager (or only a file system). Usually singletons are used for centralized management of internal or external resources and they provide a global point of access to themselves. The primary purpose of the singleton is to guarantee that at anytime there is only one instance for a given class and provide a global reference to it.

The singleton pattern is one of the simplest design patterns: it involves only one class which is responsible to instantiate itself, to make sure it creates not more than one instance; in the same time it provides a global point of access to that instance. In this case the same instance can be used from everywhere, being impossible to invoke directly the constructor each time.

Well, the question is, is it safe to use a singleton class when it might be very tempting to do so? Obviously, the answer is negative.

==== Problem 1 ====
There is a general misconception about how Singletons should be used. Some people see the Singleton as a justification for global state, along the lines of "If there's a pattern for it, it must be good". Possibly, because it is true, that for having global state, it is better using Singletons, than just plainly global variables or class objects. Well no, it isn’t. Global state is considered harmful. For a number of reasons, that even Singleton-misuse won't make go away, simply because: '''Singletons are NOT intended to provide global state!'''

The Singleton is a creational pattern. It is used to enforce, that a class be instantiated only once. What it basically does is, to give control over instantiation back to the programmer. This is what you sometimes need in languages with classical constructors (Java, C++ and such).

=== Factory ===
Create an interface for building an object, but let subclasses decide which class to instantiate. It allows a class to defer instantiation of subclasses.
Factory pattern is one of the patterns that have being heavily abused. With as long as if --- else, go to the factory model, as long as the object involved in the creation of selective, go to the factory model. Factory pattern seems to have become the panacea to solve all.
But let us look at some of the above contrast with the factory pattern, you simple code it? Wrong! The contrary, no increase in the scalability of the code at the same time, it increased the number of types of calls, an increase of the number of categories. This is not what we want to see!

One example is there is only one object to be instantiate. There was no concept of abstraction or extended classes,just plain old ClassX & ClassXFactory.

<pre>
public class A {
public String str;
public String getStr() {
return str;
}
}// End of class

public class ChildA extends A {
public ChildA(String str) {
System.out.println("Hello "+str);
}
}// End of class

public class AFactory {
public static void main(String args[]) {
AFactory factory = new AFactory();
factory.getA(args[0]);
}

public A getA(String str) {
if(str!=NULL)
return new A(str);
else
return null;
}
}
</pre>

When to use a Factory Pattern?
The Factory patterns can be used in following cases:

1. When a class does not know which class of objects it must create.

2. A class specifies its sub-classes to specify which objects to create.

3. In programmer’s language (very raw form), you can use factory pattern where you have to create an object of any one of sub-classes depending on the data provided.

=== Visitor ===
Visitor pattern represent an operation to be performed on the elements of an object structure. In GoF's word, "It let you define a new operation changing the classes of the elements on which it operates."
However, It's also the one that GoF most worried about. It's not a "necessary evil" - but is often over used and the need for it often reveals a more fundamental flaw in your design.

Following is a classic example being that you have the intersection between two shapes, but there's an even simpler case that's often overlooked: comparing the equality of two heterogeneous objects.

<pre>
interface IShape
{
double intersectWith(Triangle t);
double intersectWith(Rectangle r);
double intersectWith(Circle c);
}
</pre>

The problem with this is that you have coupled together all of your implementations of "IShape". You've implied that whenever you wish to add a new shape to the hierarchy you will need to change all the other "Shape" implementations too.

Sometimes, this is the correct minimal design - but think it through. Does your design really mandate that you need to dispatch on two types? Are you willing to write each of the combinatorial explosion of multi-methods?

Often, by introducing another concept you can reduce the number of combinations that you're actually going to have to write:

<pre>
interface IShape
{
Area getArea();
}

class Area
{
public double intersectWith(Area otherArea);
...
}
</pre>

=== Command ===
The Command design pattern encapsulates commands (method calls) in objects allowing us to issue requests without knowing the requested operation or the requesting object. Command design pattern provides the options to queue commands, undo/redo actions and other manipulations.

There are two extremes that a programmer must avoid when using this pattern:

1. The command is just a link between the receiver and the actions that carry out the request
2. The command implements everything itself, without sending anything to the receiver.

We must always keep in mind the fact that the receiver is the one who knows how to perform the operations needed, the purpose of the command being to help the client to delegate its request quickly and to make sure the command ends up where it should.

One example is:
<pre>
class FileDeleteCommand
def initialize(path)
@path = path
end
def execute
File.delete(@path)
end
end
fdc = FileDeleteCommand.new('foo.dat')
fdc.execute
</pre>
there is nothing simpler than just getting on with it:
File.delete('foo.dat')

= Conclusion =
= Reference =

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-28T02:54:20Z

Yliu63: /* Factory */

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-28T02:53:57Z

Yliu63: /* Factory */

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-28T02:52:34Z

Yliu63: /* Factory */

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-28T02:09:44Z

Yliu63: /* Factory */

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-28T01:38:27Z

Yliu63: /* Factory */

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-24T21:40:27Z

Yliu63: /* Command */

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-24T21:39:19Z

Yliu63: /* Command */

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-24T21:37:47Z

Yliu63: /* Command */

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-24T21:14:14Z

Yliu63: /* Categorization of Patterns */

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-24T21:07:25Z

Yliu63: /* Categorization of Patterns */

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-24T21:00:27Z

Yliu63: /* Symptoms of Rotting Design */

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-24T20:59:10Z

Yliu63: /* What is Pattern Fragility */

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-24T20:57:58Z

Yliu63: /* Categorization of Patterns */

File:Category.jpg

2012-10-24T20:57:22Z

Yliu63:

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-24T20:54:52Z

Yliu63: /* Categorization of Patterns */

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-24T20:52:43Z

Yliu63: /* Why Patterns */

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-24T20:52:10Z

Yliu63: /* Why Design Patterns */

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-24T20:51:49Z

Yliu63: /* Why Patterns */

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-24T20:45:05Z

Yliu63: /* Design Patterns */

CSC/ECE 517 Fall 2012/ch2a 2w14 bb

2012-10-24T20:40:33Z

Yliu63: /* Introduction */

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T03:27:13Z

Yliu63: /* Conclusion */

'''Primitive objects in object-oriented languages'''

== Introduction ==

In any programming language, the [http://en.wikipedia.org/wiki/Data_type data type] refers to the class of data which contains specific type or range of values. Data types are used along with variables used in the program. The data type tells us what kind of values the variable can store, what is the range of the values and how much space the values take in memory etc.

The [http://en.wikipedia.org/wiki/Primitive_data_type primitive data types] refer to the built-in data types which are supported by the programming language. Often 'data types' and 'primitive data types' are used interchangeably. But not all data types are primitive. Programming languages have some non-primitive data types or derived data types which are provided by the language by making use of its primitive data types.

The common built-in data types or primitive data types are integers, floating point numbers, characters, strings and boolean.
* Integers - Integers represent the whole numbers which can be positive or negative or zero, e.g. 9999, 0, -25, etc.
* Floating point numbers - Floating point numbers represent the numbers which are fractions or contain floating-decimal points, e.g. -3.002, 2.5, 22.0, etc.
* Characters - Characters represent any single letter, number, space, punctuation mark, or symbol that can be typed on a computer, e.g. 'a', '9', ' ', '!' , '\n', etc.
* Strings - Strings represent the sequences of characters or simply any text, e.g. "Hello!", "9 am to 6 pm", etc.
* Booleans - Booleans represent the true or false values. Sometimes, instead of true and false, 1 and 0 are used to represent the boolean values.

Many [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming] languages provide support for primitive data types while some object-oriented programming languages provide support for primitive objects along with primitive types.

== Definition ==

Primitive objects refer to the objects of built-in classes which provide more functionality than the primitive types. Some object-oriented programming languages provide support for only primitive objects (i.e., in such languages all primitive types are objects).

Different object-oriented programming languages implement these primitive data types and primitive objects in a different manner.

== Primitive objects in different OO languages ==
=== Java ===

In [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java], there are 8 primitive types: boolean, char, byte, short, int, long, float, and double. <ref>http://www.cafeaulait.org/course/week2/02.html Java's Primitive Data Types</ref>

For each of these primitive types, Java provides [http://en.wikipedia.org/wiki/Primitive_wrapper_class wrapper classes] to create primitive objects which wrap the primitive data values. A wrapper not only contains the primitive data value, but it also defines properties and methods that can be used to manipulate that data. In Java, the primitive values are not implicitly converted to primitive objects. Instead, methods are provided for doing explicit conversion.
The primitive objects are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack heap] in memory while the variables containing primitive values are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack stack].<ref>http://www.informit.com/articles/article.aspx?p=31755&seqNum=8 Stack and Heap memory</ref>

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class!! Size
|-
| boolean || Boolean || 1-bit
|-
| char || Character || 16-bit
|-
| byte || Byte || 8-bit
|-
| short || Short || 16-bit
|-
| int || Integer || 32-bit
|-
| long || Long || 64-bit
|-
| float || Float || 32-bit
|-
| double || Double || 64-bit
|}

Example:
int i = 10;
int ii = 20;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I+II);
System.out.println(I.equals(II));

Output:
30
false

To find out if these wrapper classes are primitive or not, we can use the isPrimitive() method.

System.out.println(INTEGER.TYPE.isPrimitive());
System.out.println(BOOLEAN.TYPE.isPrimitive());

Output:
true
true

In Java, the comparison operations work in the same way on the primitive objects as well as any other class objects but different on the primitive types. The == operator when used on objects checks whether they refer to the same object but when used on variables of primitive types checks whether they contain the same value.<ref>http://leepoint.net/notes-java/data/expressions/22compareobjects.html Comparisons in Java</ref>

Example:
int i = 10;
int ii = 10;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I==II);
System.out.println(i==ii);

Output:
false
true

=== C# ===

[http://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29 C#] is a [http://en.wikipedia.org/wiki/Strong_typing strongly typed] language, where it is necessary to declare the data type of a variable and also be aware of the data type conversion. C# provides a significant number of primitive data types.<ref>http://condor.depaul.edu/sjost/ndp/notes/cs1/CSDatatypes.htm C# Primitive Datatypes</ref><ref>http://www.java2s.com/Tutorial/CSharp/0040__Data-Type/PrimitivesinC.htm Primitives in C#</ref>

Because C# represents all primitive data types as objects, it is possible to call an object method on a primitive data type. For example:

static void Main()
{
int x = 7;
object o = x;
System.Console.WriteLine(o.ToString());
}

Some data types (e.g. Decimal and String) can appear like primitives at first sight, but are actually not. So it is important to exercise caution before making such assumptions. To test whether a particular type is a primitive or not you can use the property Type.IsPrimitive.

Consider the following example:

if (t.IsPrimitive) // where t is the type
{
// Is Primitive
} else if (t == typeof(Decimal))
{
// Is Decimal
} else if (t == typeof(String))
{
// Is String
} else
{
// Other type
}

=== JavaScript ===

There are 5 primitive data types in [http://en.wikipedia.org/wiki/JavaScript JavaScript]: string, number, boolean, null and undefined. <ref>http://oreilly.com/javascript/excerpts/learning-javascript/javascript-datatypes-variables.html JavaScript Data Types and Variables</ref>

For string, number and boolean values, there are corresponding classes just like in Java to create primitive objects which wrap the primitive values.

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class
|-
| string || String
|-
| number|| Number
|-
| boolean || Boolean
|}

In JavaScript, the primitive value is implicitly converted to a primitive object whenever someone tries to access a property or invoke a method on the primitive value and the primitive object is used in place of the primitive value. Since the object contains properties and methods, the use of primitive value as an object succeeds. After the property is accessed or the method is processed, the primitive object is no longer needed and hence discarded. The same is true for the other primitive types and their corresponding primitive objects.

Example:

var upperCaseString = "APPLE";
var lowerCaseString = upperCaseString.toLowerCase(); // assigns string "apple" to lowerCaseString
var s = "Hello"
var len = s.length; // assigns value 5 to len

=== Ruby ===

Since [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is a [http://www.jvoegele.com/software/langcomp.html pure object oriented] language, everything in Ruby is an object. Hence, all primitive types such as integers, floating point numbers, strings, are objects of a built-in class.<ref>http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html Classes in Ruby</ref>
All integers are primitive objects of either class [http://corelib.rubyonrails.org/classes/Fixnum.html Fixnum] or [http://corelib.rubyonrails.org/classes/Bignum.html Bignum]. A numeric literal with a decimal point and/or an exponent is a primitive object of [http://corelib.rubyonrails.org/classes/Float.html Float]. Single quoted literals and double quoted literals are primitive objects of [http://corelib.rubyonrails.org/classes/String.html String].

Example:

puts 10.class
puts 7.45.class
puts 'hi'.class
puts "hello".class

Output:

Fixnum
Float
String
String

This indicates that 10 is converted into an object of type Fixnum, 7.45 is converted into an object of type Float, 'hi' and "hello" are both converted into an object of type String.

Since all primitive types in Ruby are objects, we should be able to call methods of the Object class on them. Let us demonstrate the same for integer and float using the following example:

a=10
puts a.to_f
b=20.5
puts b.to_i

Output:
10.0
20

== Advantages of primitives ==

Advantages that use of primitive data type offers are as follows:
===Consistency===
Many ideas of Java originate in C and in C++, objects and primitive type also co-exist. When object-oriented constructs were grafted onto the C language, C’s data types remained as is. The motivation behind this is that Bjarne Stroustrup, C++’s designer, wanted to be as consistent as possible with the base C language, hoping to capitalize on programmers’ pre-C++ knowledge.
<ref>http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Primitive Types Considered Harmful</ref>

===Simplicity===
It is simple and intuitive to use primitive data type in basic utility.

Example:

1. Recurring number in a loop.(C++)

for(int i=0;i<10;i++)

2. Temp variables that record only one or two data.

===Time performance===
Processing primitive data type operation would be faster than processing composite data type in most cases. There are several reasons result in this differences.
*Hardware processing discrepancy
Many primitive data operations (like integer addition) can be performed as a single machine instruction while processing of composite data type would be transformed to a combination of primitive data types. eg. Some processors offer specific instructions to process sequences of characters with a single instruction.

Example:

[http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Difference in data fetching between primitive data and composite data in Java]

*Allocating and Garbage collection overhead for composite data type<ref>http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Performance_implications Garbage collection</ref><ref>http://www.ibm.com/developerworks/java/library/j-jtp01274/index.html Java theory and practice: Garbage collection and performance</ref>
There are many initialization operations for composite data type that will generate high overheads for example boxing and unboxing, constructors and destructors.Composite data type like class will also have garbage collection overheads that may be beyond the control of the programmer and can sometimes lead to performance problems. For example, commonly used stop-the-world garbage collectors, which pause program execution at arbitrary times, may make garbage collection inappropriate for some [http://en.wikipedia.org/wiki/Embedded_system embedded systems], high-performance [http://en.wikipedia.org/wiki/Server_(computing) server] software, and applications with [http://en.wikipedia.org/wiki/Real-time_computing real-time] needs.In the early days of Java technology, allocating objects got a high overheads. There were lots of articles advising developers to avoid creating temporary objects unnecessarily because allocation (and the corresponding garbage-collection overhead) was expensive. Although the costs have been greatly reduced nowadays. It still much slower than primitive data type which don’t have such troubles.

Example:

public void test1(){
int a=1,b=1;
long startTime1 = System.currentTimeMillis();
for(int i=0;i<N;i++){
a=a+b;
}
long endTime1 = System.currentTimeMillis();
System.out.println(endTime1-startTime1);
}

public void test2(){
Integer c=new Integer(1);
Integer d=new Integer(1);
long startTime2 = System.currentTimeMillis();
for(int i=0;i<N;i++){
c=c+d;
}
long endTime2 = System.currentTimeMillis();
System.out.println(endTime2-startTime2)
}

Average execution time for test1 is: 1 mm

Average execution time for test2 is: 702mm

(test case number: 1000 times )

===Space performance===
Composite data type will cost more memory space than primitive data type in general. The reason is not only for the overheads generated by constructors, destructors etc, but also the feature of data alignment. <ref>http://en.wikipedia.org/wiki/Data_structure_alignment#Data_structure_padding Data structure alignment</ref>

Example of data alignment（C++）
struct compose
{
char name;
int a;
int b;
}

We all know the size of char is 1 byte, the size of int is 4 bytes. But the size of the struct compose as shown above is 12 bytes but not 9 bytes.

== Disdvantages of primitives ==

The various disadvantages of using the primitive data types are as follows:

===Cannot be extended===
We can use a class or array to model the intricate data or functional structure. With the feature of class, programmers can create subtypes, modify their operations and even redefine them. In addition with the feature of class, programmers can make their variables unchangeable to any code outside the class, or make the implementation hidden to other code with call the methods. That means with composite data types, it will be more convenient for the programmers to handle sophisticated data and also make the code easier to maintain.

In the following example, we create a Person type in RUBY. We defined a “talk” method to make a Person can talk about himself. We also hope to only make the variable “motherland” changeable by the code outside this class.

Example: (in RUBY)

class Person

def initialize( name, age=18 )
@name = name
@age = age
@motherland = "US"
end

def talk
puts "my name is "+@name+", age is "+@age.to_s
if @motherland == "US"
puts "I\'m American."
else
puts "I\'m International."
end
end
attr_writer :motherland
end

Later when we need to create a “Student” type, we can just inherent the “Person” type and make some adjustment based on our needs. Here we redefine the “talk” method to make a student talk in a different way.

class Student < Person

def talk
puts "I am a student. my name is "+@name+", age is "+@age.to_s
end
end

===Inability on handling large scale data===
Though it means more processing time, it is necessary for programmers to create composite type to handle the data whose length is too large or changing all the time. If we have a set or integers to maintain in memory, but the number of integers will change every second, it will be impossible if we only use primitive types to handle. But we can make use of the “Arraylist” type in Java or other composite types. With the “Arraylist”, the programmers do not need to pay attention to the storage in the memory or the space it takes. The compiler of Java will reallocate more space automatically for the Arraylist if more elements are putted. <ref>http://docs.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html Inability on handling large scale data</ref>

Example of the insert and sorting methods of the Arraylist type in Java:

ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.Sort();

===Limitation on size===

For the primitive data types in most programming languages, there are some limits of the size. For example we can put an integer between -(2^16) and (2^16)-1 into an “int” in Java. That will be enough for some most of the cases but definitely not all of them. For example, the primitive types are not enough for a scientific calculation if we need an accuracy on 10^-500. And a more extreme case is to calculate the last 100 numbers for the PI has a 100 million length.

For these situations, the programmers usually need to create a composite data type by themselves. They can even redefine the operators (“+”, “-”) to make the super-long float also can make addition, subtraction with ordinary operators instead of method calling. For more details to create a super long float please see reference.<ref>http://en.verysource.com/code/1285797_1/tlargefloat.h.html Limitation on size</ref>

===Not supporting utility methods===
Most of the object oriented languages have certain utility methods associated with non primitive data types that ease their use as compared to primitive data types that do not have such methods.<ref>http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Not supporting utility methods</ref>.

An especially useful example is the method of parsing integers in a specified radix in Java (Integer.parseInt).

parseInt("1100110", 2); //returns 102
parseInt("-0", 10); //returns 0
parseInt("-FF", 16); //returns -255
parseInt("99", 8); //throws a NumberFormatException

From the above examples, it is obvious that “Integer” type not just support ordinary methods an integer should have (such as Integer.equals), but also some more utility methods which are helpful for the programmers.

In addition, for some data structure which only take object but not primitive type (such as Vector in Java), it is necessary to box a primitive data type to a corresponding object. For example if a programmer needs to make use of a vector to store some integer, it is necessary to box the ints and floats first:

Vector　v=new Vector();
int k=121;
v.addElemt(new Integer(k));

===Functionality===
Discussion of advantages and disadvantages should concerned the functionality you want to implement. For example if you want to operate a serials of int number. The performance of array may be better than int. <ref>http://cs.smith.edu/~thiebaut/ArtOfAssembly/CH05/CH05-2.html Composite datatypes</ref>

[[File:1w1.gif]]

To access an element of an array, you need a function that converts an array index into the address of the indexed element. For a single dimension array, this function is very simple. It is
Element_Address = Base_Address + ((Index - Initial_Index) * Element_Size)

However, If you use five primitive data type to implement the same function. It may cost more time for the cpu to search the address of each data.

== Conclusion ==
In a nutshell, composite data type is more likely to stand out the features of object-oriented language and be widely used. However,primitive data type would not disappear in a foreseeable future because of its advantage in performance and use. It bridges the gap between novice programmers and experienced programmers by making powerful features basic to the language and makes coding simpler. Dealing with primitive objects is easier at times.

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T03:22:16Z

Yliu63: /* Conclusion */

'''Primitive objects in object-oriented languages'''

== Introduction ==

In any programming language, the [http://en.wikipedia.org/wiki/Data_type data type] refers to the class of data which contains specific type or range of values. Data types are used along with variables used in the program. The data type tells us what kind of values the variable can store, what is the range of the values and how much space the values take in memory etc.

The [http://en.wikipedia.org/wiki/Primitive_data_type primitive data types] refer to the built-in data types which are supported by the programming language. Often 'data types' and 'primitive data types' are used interchangeably. But not all data types are primitive. Programming languages have some non-primitive data types or derived data types which are provided by the language by making use of its primitive data types.

The common built-in data types or primitive data types are integers, floating point numbers, characters, strings and boolean.
* Integers - Integers represent the whole numbers which can be positive or negative or zero, e.g. 9999, 0, -25, etc.
* Floating point numbers - Floating point numbers represent the numbers which are fractions or contain floating-decimal points, e.g. -3.002, 2.5, 22.0, etc.
* Characters - Characters represent any single letter, number, space, punctuation mark, or symbol that can be typed on a computer, e.g. 'a', '9', ' ', '!' , '\n', etc.
* Strings - Strings represent the sequences of characters or simply any text, e.g. "Hello!", "9 am to 6 pm", etc.
* Booleans - Booleans represent the true or false values. Sometimes, instead of true and false, 1 and 0 are used to represent the boolean values.

Many [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming] languages provide support for primitive data types while some object-oriented programming languages provide support for primitive objects along with primitive types.

== Definition ==

Primitive objects refer to the objects of built-in classes which provide more functionality than the primitive types. Some object-oriented programming languages provide support for only primitive objects (i.e., in such languages all primitive types are objects).

Different object-oriented programming languages implement these primitive data types and primitive objects in a different manner.

== Primitive objects in different OO languages ==
=== Java ===

In [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java], there are 8 primitive types: boolean, char, byte, short, int, long, float, and double. <ref>http://www.cafeaulait.org/course/week2/02.html Java's Primitive Data Types</ref>

For each of these primitive types, Java provides [http://en.wikipedia.org/wiki/Primitive_wrapper_class wrapper classes] to create primitive objects which wrap the primitive data values. A wrapper not only contains the primitive data value, but it also defines properties and methods that can be used to manipulate that data. In Java, the primitive values are not implicitly converted to primitive objects. Instead, methods are provided for doing explicit conversion.
The primitive objects are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack heap] in memory while the variables containing primitive values are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack stack].<ref>http://www.informit.com/articles/article.aspx?p=31755&seqNum=8 Stack and Heap memory</ref>

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class!! Size
|-
| boolean || Boolean || 1-bit
|-
| char || Character || 16-bit
|-
| byte || Byte || 8-bit
|-
| short || Short || 16-bit
|-
| int || Integer || 32-bit
|-
| long || Long || 64-bit
|-
| float || Float || 32-bit
|-
| double || Double || 64-bit
|}

Example:
int i = 10;
int ii = 20;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I+II);
System.out.println(I.equals(II));

Output:
30
false

To find out if these wrapper classes are primitive or not, we can use the isPrimitive() method.

System.out.println(INTEGER.TYPE.isPrimitive());
System.out.println(BOOLEAN.TYPE.isPrimitive());

Output:
true
true

In Java, the comparison operations work in the same way on the primitive objects as well as any other class objects but different on the primitive types. The == operator when used on objects checks whether they refer to the same object but when used on variables of primitive types checks whether they contain the same value.<ref>http://leepoint.net/notes-java/data/expressions/22compareobjects.html Comparisons in Java</ref>

Example:
int i = 10;
int ii = 10;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I==II);
System.out.println(i==ii);

Output:
false
true

=== C# ===

[http://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29 C#] is a [http://en.wikipedia.org/wiki/Strong_typing strongly typed] language, where it is necessary to declare the data type of a variable and also be aware of the data type conversion. C# provides a significant number of primitive data types.<ref>http://condor.depaul.edu/sjost/ndp/notes/cs1/CSDatatypes.htm C# Primitive Datatypes</ref><ref>http://www.java2s.com/Tutorial/CSharp/0040__Data-Type/PrimitivesinC.htm Primitives in C#</ref>

Because C# represents all primitive data types as objects, it is possible to call an object method on a primitive data type. For example:

static void Main()
{
int x = 7;
object o = x;
System.Console.WriteLine(o.ToString());
}

Some data types (e.g. Decimal and String) can appear like primitives at first sight, but are actually not. So it is important to exercise caution before making such assumptions. To test whether a particular type is a primitive or not you can use the property Type.IsPrimitive.

Consider the following example:

if (t.IsPrimitive) // where t is the type
{
// Is Primitive
} else if (t == typeof(Decimal))
{
// Is Decimal
} else if (t == typeof(String))
{
// Is String
} else
{
// Other type
}

=== JavaScript ===

There are 5 primitive data types in [http://en.wikipedia.org/wiki/JavaScript JavaScript]: string, number, boolean, null and undefined. <ref>http://oreilly.com/javascript/excerpts/learning-javascript/javascript-datatypes-variables.html JavaScript Data Types and Variables</ref>

For string, number and boolean values, there are corresponding classes just like in Java to create primitive objects which wrap the primitive values.

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class
|-
| string || String
|-
| number|| Number
|-
| boolean || Boolean
|}

In JavaScript, the primitive value is implicitly converted to a primitive object whenever someone tries to access a property or invoke a method on the primitive value and the primitive object is used in place of the primitive value. Since the object contains properties and methods, the use of primitive value as an object succeeds. After the property is accessed or the method is processed, the primitive object is no longer needed and hence discarded. The same is true for the other primitive types and their corresponding primitive objects.

Example:

var upperCaseString = "APPLE";
var lowerCaseString = upperCaseString.toLowerCase(); // assigns string "apple" to lowerCaseString
var s = "Hello"
var len = s.length; // assigns value 5 to len

=== Ruby ===

Since [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is a [http://www.jvoegele.com/software/langcomp.html pure object oriented] language, everything in Ruby is an object. Hence, all primitive types such as integers, floating point numbers, strings, are objects of a built-in class.<ref>http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html Classes in Ruby</ref>
All integers are primitive objects of either class [http://corelib.rubyonrails.org/classes/Fixnum.html Fixnum] or [http://corelib.rubyonrails.org/classes/Bignum.html Bignum]. A numeric literal with a decimal point and/or an exponent is a primitive object of [http://corelib.rubyonrails.org/classes/Float.html Float]. Single quoted literals and double quoted literals are primitive objects of [http://corelib.rubyonrails.org/classes/String.html String].

Example:

puts 10.class
puts 7.45.class
puts 'hi'.class
puts "hello".class

Output:

Fixnum
Float
String
String

This indicates that 10 is converted into an object of type Fixnum, 7.45 is converted into an object of type Float, 'hi' and "hello" are both converted into an object of type String.

Since all primitive types in Ruby are objects, we should be able to call methods of the Object class on them. Let us demonstrate the same for integer and float using the following example:

a=10
puts a.to_f
b=20.5
puts b.to_i

Output:
10.0
20

== Advantages of primitives ==

Advantages that use of primitive data type offers are as follows:
===Consistency===
Many ideas of Java originate in C and in C++, objects and primitive type also co-exist. When object-oriented constructs were grafted onto the C language, C’s data types remained as is. The motivation behind this is that Bjarne Stroustrup, C++’s designer, wanted to be as consistent as possible with the base C language, hoping to capitalize on programmers’ pre-C++ knowledge.
<ref>http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Primitive Types Considered Harmful</ref>

===Simplicity===
It is simple and intuitive to use primitive data type in basic utility.

Example:

1. Recurring number in a loop.(C++)

for(int i=0;i<10;i++)

2. Temp variables that record only one or two data.

===Time performance===
Processing primitive data type operation would be faster than processing composite data type in most cases. There are several reasons result in this differences.
*Hardware processing discrepancy
Many primitive data operations (like integer addition) can be performed as a single machine instruction while processing of composite data type would be transformed to a combination of primitive data types. eg. Some processors offer specific instructions to process sequences of characters with a single instruction.

Example:

[http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Difference in data fetching between primitive data and composite data in Java]

*Allocating and Garbage collection overhead for composite data type<ref>http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Performance_implications Garbage collection</ref><ref>http://www.ibm.com/developerworks/java/library/j-jtp01274/index.html Java theory and practice: Garbage collection and performance</ref>
There are many initialization operations for composite data type that will generate high overheads for example boxing and unboxing, constructors and destructors.Composite data type like class will also have garbage collection overheads that may be beyond the control of the programmer and can sometimes lead to performance problems. For example, commonly used stop-the-world garbage collectors, which pause program execution at arbitrary times, may make garbage collection inappropriate for some [http://en.wikipedia.org/wiki/Embedded_system embedded systems], high-performance [http://en.wikipedia.org/wiki/Server_(computing) server] software, and applications with [http://en.wikipedia.org/wiki/Real-time_computing real-time] needs.In the early days of Java technology, allocating objects got a high overheads. There were lots of articles advising developers to avoid creating temporary objects unnecessarily because allocation (and the corresponding garbage-collection overhead) was expensive. Although the costs have been greatly reduced nowadays. It still much slower than primitive data type which don’t have such troubles.

Example:

public void test1(){
int a=1,b=1;
long startTime1 = System.currentTimeMillis();
for(int i=0;i<N;i++){
a=a+b;
}
long endTime1 = System.currentTimeMillis();
System.out.println(endTime1-startTime1);
}

public void test2(){
Integer c=new Integer(1);
Integer d=new Integer(1);
long startTime2 = System.currentTimeMillis();
for(int i=0;i<N;i++){
c=c+d;
}
long endTime2 = System.currentTimeMillis();
System.out.println(endTime2-startTime2)
}

Average execution time for test1 is: 1 mm

Average execution time for test2 is: 702mm

(test case number: 1000 times )

===Space performance===
Composite data type will cost more memory space than primitive data type in general. The reason is not only for the overheads generated by constructors, destructors etc, but also the feature of data alignment. <ref>http://en.wikipedia.org/wiki/Data_structure_alignment#Data_structure_padding Data structure alignment</ref>

Example of data alignment（C++）
struct compose
{
char name;
int a;
int b;
}

We all know the size of char is 1 byte, the size of int is 4 bytes. But the size of the struct compose as shown above is 12 bytes but not 9 bytes.

== Disdvantages of primitives ==

The various disadvantages of using the primitive data types are as follows:

===Cannot be extended===
We can use a class or array to model the intricate data or functional structure. With the feature of class, programmers can create subtypes, modify their operations and even redefine them. In addition with the feature of class, programmers can make their variables unchangeable to any code outside the class, or make the implementation hidden to other code with call the methods. That means with composite data types, it will be more convenient for the programmers to handle sophisticated data and also make the code easier to maintain.

In the following example, we create a Person type in RUBY. We defined a “talk” method to make a Person can talk about himself. We also hope to only make the variable “motherland” changeable by the code outside this class.

Example: (in RUBY)

class Person

def initialize( name, age=18 )
@name = name
@age = age
@motherland = "US"
end

def talk
puts "my name is "+@name+", age is "+@age.to_s
if @motherland == "US"
puts "I\'m American."
else
puts "I\'m International."
end
end
attr_writer :motherland
end

Later when we need to create a “Student” type, we can just inherent the “Person” type and make some adjustment based on our needs. Here we redefine the “talk” method to make a student talk in a different way.

class Student < Person

def talk
puts "I am a student. my name is "+@name+", age is "+@age.to_s
end
end

===Inability on handling large scale data===
Though it means more processing time, it is necessary for programmers to create composite type to handle the data whose length is too large or changing all the time. If we have a set or integers to maintain in memory, but the number of integers will change every second, it will be impossible if we only use primitive types to handle. But we can make use of the “Arraylist” type in Java or other composite types. With the “Arraylist”, the programmers do not need to pay attention to the storage in the memory or the space it takes. The compiler of Java will reallocate more space automatically for the Arraylist if more elements are putted. <ref>http://docs.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html Inability on handling large scale data</ref>

Example of the insert and sorting methods of the Arraylist type in Java:

ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.Sort();

===Limitation on size===

For the primitive data types in most programming languages, there are some limits of the size. For example we can put an integer between -(2^16) and (2^16)-1 into an “int” in Java. That will be enough for some most of the cases but definitely not all of them. For example, the primitive types are not enough for a scientific calculation if we need an accuracy on 10^-500. And a more extreme case is to calculate the last 100 numbers for the PI has a 100 million length.

For these situations, the programmers usually need to create a composite data type by themselves. They can even redefine the operators (“+”, “-”) to make the super-long float also can make addition, subtraction with ordinary operators instead of method calling. For more details to create a super long float please see reference.<ref>http://en.verysource.com/code/1285797_1/tlargefloat.h.html Limitation on size</ref>

===Not supporting utility methods===
Most of the object oriented languages have certain utility methods associated with non primitive data types that ease their use as compared to primitive data types that do not have such methods.<ref>http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Not supporting utility methods</ref>.

An especially useful example is the method of parsing integers in a specified radix in Java (Integer.parseInt).

parseInt("1100110", 2); //returns 102
parseInt("-0", 10); //returns 0
parseInt("-FF", 16); //returns -255
parseInt("99", 8); //throws a NumberFormatException

From the above examples, it is obvious that “Integer” type not just support ordinary methods an integer should have (such as Integer.equals), but also some more utility methods which are helpful for the programmers.

In addition, for some data structure which only take object but not primitive type (such as Vector in Java), it is necessary to box a primitive data type to a corresponding object. For example if a programmer needs to make use of a vector to store some integer, it is necessary to box the ints and floats first:

Vector　v=new Vector();
int k=121;
v.addElemt(new Integer(k));

===Functionality===
Discussion of advantages and disadvantages should concerned the functionality you want to implement. For example if you want to operate a serials of int number. The performance of array may be better than int. <ref>http://cs.smith.edu/~thiebaut/ArtOfAssembly/CH05/CH05-2.html Composite datatypes</ref>

[[File:1w1.gif]]

To access an element of an array, you need a function that converts an array index into the address of the indexed element. For a single dimension array, this function is very simple. It is
Element_Address = Base_Address + ((Index - Initial_Index) * Element_Size)

However, If you use five primitive data type to implement the same function. It may cost more time for the cpu to search the address of each data.

== Conclusion ==
In a nutshell,composite data type is more likely to stand out the features of object-oriented language and be widely used. However,primitive data type would not disappear in a foreseeable future because of its advantage in performance and use. It bridges the gap between novice programmers and experienced programmers by making powerful features basic to the language and makes coding simpler. Dealing with primitive objects is easier at times. In brief, the primitive objects help to increase the productivity of the programmers.

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T03:21:41Z

Yliu63: /* Conclusion */

'''Primitive objects in object-oriented languages'''

== Introduction ==

In any programming language, the [http://en.wikipedia.org/wiki/Data_type data type] refers to the class of data which contains specific type or range of values. Data types are used along with variables used in the program. The data type tells us what kind of values the variable can store, what is the range of the values and how much space the values take in memory etc.

The [http://en.wikipedia.org/wiki/Primitive_data_type primitive data types] refer to the built-in data types which are supported by the programming language. Often 'data types' and 'primitive data types' are used interchangeably. But not all data types are primitive. Programming languages have some non-primitive data types or derived data types which are provided by the language by making use of its primitive data types.

The common built-in data types or primitive data types are integers, floating point numbers, characters, strings and boolean.
* Integers - Integers represent the whole numbers which can be positive or negative or zero, e.g. 9999, 0, -25, etc.
* Floating point numbers - Floating point numbers represent the numbers which are fractions or contain floating-decimal points, e.g. -3.002, 2.5, 22.0, etc.
* Characters - Characters represent any single letter, number, space, punctuation mark, or symbol that can be typed on a computer, e.g. 'a', '9', ' ', '!' , '\n', etc.
* Strings - Strings represent the sequences of characters or simply any text, e.g. "Hello!", "9 am to 6 pm", etc.
* Booleans - Booleans represent the true or false values. Sometimes, instead of true and false, 1 and 0 are used to represent the boolean values.

Many [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming] languages provide support for primitive data types while some object-oriented programming languages provide support for primitive objects along with primitive types.

== Definition ==

Primitive objects refer to the objects of built-in classes which provide more functionality than the primitive types. Some object-oriented programming languages provide support for only primitive objects (i.e., in such languages all primitive types are objects).

Different object-oriented programming languages implement these primitive data types and primitive objects in a different manner.

== Primitive objects in different OO languages ==
=== Java ===

In [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java], there are 8 primitive types: boolean, char, byte, short, int, long, float, and double. <ref>http://www.cafeaulait.org/course/week2/02.html Java's Primitive Data Types</ref>

For each of these primitive types, Java provides [http://en.wikipedia.org/wiki/Primitive_wrapper_class wrapper classes] to create primitive objects which wrap the primitive data values. A wrapper not only contains the primitive data value, but it also defines properties and methods that can be used to manipulate that data. In Java, the primitive values are not implicitly converted to primitive objects. Instead, methods are provided for doing explicit conversion.
The primitive objects are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack heap] in memory while the variables containing primitive values are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack stack].<ref>http://www.informit.com/articles/article.aspx?p=31755&seqNum=8 Stack and Heap memory</ref>

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class!! Size
|-
| boolean || Boolean || 1-bit
|-
| char || Character || 16-bit
|-
| byte || Byte || 8-bit
|-
| short || Short || 16-bit
|-
| int || Integer || 32-bit
|-
| long || Long || 64-bit
|-
| float || Float || 32-bit
|-
| double || Double || 64-bit
|}

Example:
int i = 10;
int ii = 20;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I+II);
System.out.println(I.equals(II));

Output:
30
false

To find out if these wrapper classes are primitive or not, we can use the isPrimitive() method.

System.out.println(INTEGER.TYPE.isPrimitive());
System.out.println(BOOLEAN.TYPE.isPrimitive());

Output:
true
true

In Java, the comparison operations work in the same way on the primitive objects as well as any other class objects but different on the primitive types. The == operator when used on objects checks whether they refer to the same object but when used on variables of primitive types checks whether they contain the same value.<ref>http://leepoint.net/notes-java/data/expressions/22compareobjects.html Comparisons in Java</ref>

Example:
int i = 10;
int ii = 10;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I==II);
System.out.println(i==ii);

Output:
false
true

=== C# ===

[http://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29 C#] is a [http://en.wikipedia.org/wiki/Strong_typing strongly typed] language, where it is necessary to declare the data type of a variable and also be aware of the data type conversion. C# provides a significant number of primitive data types.<ref>http://condor.depaul.edu/sjost/ndp/notes/cs1/CSDatatypes.htm C# Primitive Datatypes</ref><ref>http://www.java2s.com/Tutorial/CSharp/0040__Data-Type/PrimitivesinC.htm Primitives in C#</ref>

Because C# represents all primitive data types as objects, it is possible to call an object method on a primitive data type. For example:

static void Main()
{
int x = 7;
object o = x;
System.Console.WriteLine(o.ToString());
}

Some data types (e.g. Decimal and String) can appear like primitives at first sight, but are actually not. So it is important to exercise caution before making such assumptions. To test whether a particular type is a primitive or not you can use the property Type.IsPrimitive.

Consider the following example:

if (t.IsPrimitive) // where t is the type
{
// Is Primitive
} else if (t == typeof(Decimal))
{
// Is Decimal
} else if (t == typeof(String))
{
// Is String
} else
{
// Other type
}

=== JavaScript ===

There are 5 primitive data types in [http://en.wikipedia.org/wiki/JavaScript JavaScript]: string, number, boolean, null and undefined. <ref>http://oreilly.com/javascript/excerpts/learning-javascript/javascript-datatypes-variables.html JavaScript Data Types and Variables</ref>

For string, number and boolean values, there are corresponding classes just like in Java to create primitive objects which wrap the primitive values.

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class
|-
| string || String
|-
| number|| Number
|-
| boolean || Boolean
|}

In JavaScript, the primitive value is implicitly converted to a primitive object whenever someone tries to access a property or invoke a method on the primitive value and the primitive object is used in place of the primitive value. Since the object contains properties and methods, the use of primitive value as an object succeeds. After the property is accessed or the method is processed, the primitive object is no longer needed and hence discarded. The same is true for the other primitive types and their corresponding primitive objects.

Example:

var upperCaseString = "APPLE";
var lowerCaseString = upperCaseString.toLowerCase(); // assigns string "apple" to lowerCaseString
var s = "Hello"
var len = s.length; // assigns value 5 to len

=== Ruby ===

Since [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is a [http://www.jvoegele.com/software/langcomp.html pure object oriented] language, everything in Ruby is an object. Hence, all primitive types such as integers, floating point numbers, strings, are objects of a built-in class.<ref>http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html Classes in Ruby</ref>
All integers are primitive objects of either class [http://corelib.rubyonrails.org/classes/Fixnum.html Fixnum] or [http://corelib.rubyonrails.org/classes/Bignum.html Bignum]. A numeric literal with a decimal point and/or an exponent is a primitive object of [http://corelib.rubyonrails.org/classes/Float.html Float]. Single quoted literals and double quoted literals are primitive objects of [http://corelib.rubyonrails.org/classes/String.html String].

Example:

puts 10.class
puts 7.45.class
puts 'hi'.class
puts "hello".class

Output:

Fixnum
Float
String
String

This indicates that 10 is converted into an object of type Fixnum, 7.45 is converted into an object of type Float, 'hi' and "hello" are both converted into an object of type String.

Since all primitive types in Ruby are objects, we should be able to call methods of the Object class on them. Let us demonstrate the same for integer and float using the following example:

a=10
puts a.to_f
b=20.5
puts b.to_i

Output:
10.0
20

== Advantages of primitives ==

Advantages that use of primitive data type offers are as follows:
===Consistency===
Many ideas of Java originate in C and in C++, objects and primitive type also co-exist. When object-oriented constructs were grafted onto the C language, C’s data types remained as is. The motivation behind this is that Bjarne Stroustrup, C++’s designer, wanted to be as consistent as possible with the base C language, hoping to capitalize on programmers’ pre-C++ knowledge.
<ref>http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Primitive Types Considered Harmful</ref>

===Simplicity===
It is simple and intuitive to use primitive data type in basic utility.

Example:

1. Recurring number in a loop.(C++)

for(int i=0;i<10;i++)

2. Temp variables that record only one or two data.

===Time performance===
Processing primitive data type operation would be faster than processing composite data type in most cases. There are several reasons result in this differences.
*Hardware processing discrepancy
Many primitive data operations (like integer addition) can be performed as a single machine instruction while processing of composite data type would be transformed to a combination of primitive data types. eg. Some processors offer specific instructions to process sequences of characters with a single instruction.

Example:

[http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Difference in data fetching between primitive data and composite data in Java]

*Allocating and Garbage collection overhead for composite data type<ref>http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Performance_implications Garbage collection</ref><ref>http://www.ibm.com/developerworks/java/library/j-jtp01274/index.html Java theory and practice: Garbage collection and performance</ref>
There are many initialization operations for composite data type that will generate high overheads for example boxing and unboxing, constructors and destructors.Composite data type like class will also have garbage collection overheads that may be beyond the control of the programmer and can sometimes lead to performance problems. For example, commonly used stop-the-world garbage collectors, which pause program execution at arbitrary times, may make garbage collection inappropriate for some [http://en.wikipedia.org/wiki/Embedded_system embedded systems], high-performance [http://en.wikipedia.org/wiki/Server_(computing) server] software, and applications with [http://en.wikipedia.org/wiki/Real-time_computing real-time] needs.In the early days of Java technology, allocating objects got a high overheads. There were lots of articles advising developers to avoid creating temporary objects unnecessarily because allocation (and the corresponding garbage-collection overhead) was expensive. Although the costs have been greatly reduced nowadays. It still much slower than primitive data type which don’t have such troubles.

Example:

public void test1(){
int a=1,b=1;
long startTime1 = System.currentTimeMillis();
for(int i=0;i<N;i++){
a=a+b;
}
long endTime1 = System.currentTimeMillis();
System.out.println(endTime1-startTime1);
}

public void test2(){
Integer c=new Integer(1);
Integer d=new Integer(1);
long startTime2 = System.currentTimeMillis();
for(int i=0;i<N;i++){
c=c+d;
}
long endTime2 = System.currentTimeMillis();
System.out.println(endTime2-startTime2)
}

Average execution time for test1 is: 1 mm

Average execution time for test2 is: 702mm

(test case number: 1000 times )

===Space performance===
Composite data type will cost more memory space than primitive data type in general. The reason is not only for the overheads generated by constructors, destructors etc, but also the feature of data alignment. <ref>http://en.wikipedia.org/wiki/Data_structure_alignment#Data_structure_padding Data structure alignment</ref>

Example of data alignment（C++）
struct compose
{
char name;
int a;
int b;
}

We all know the size of char is 1 byte, the size of int is 4 bytes. But the size of the struct compose as shown above is 12 bytes but not 9 bytes.

== Disdvantages of primitives ==

The various disadvantages of using the primitive data types are as follows:

===Cannot be extended===
We can use a class or array to model the intricate data or functional structure. With the feature of class, programmers can create subtypes, modify their operations and even redefine them. In addition with the feature of class, programmers can make their variables unchangeable to any code outside the class, or make the implementation hidden to other code with call the methods. That means with composite data types, it will be more convenient for the programmers to handle sophisticated data and also make the code easier to maintain.

In the following example, we create a Person type in RUBY. We defined a “talk” method to make a Person can talk about himself. We also hope to only make the variable “motherland” changeable by the code outside this class.

Example: (in RUBY)

class Person

def initialize( name, age=18 )
@name = name
@age = age
@motherland = "US"
end

def talk
puts "my name is "+@name+", age is "+@age.to_s
if @motherland == "US"
puts "I\'m American."
else
puts "I\'m International."
end
end
attr_writer :motherland
end

Later when we need to create a “Student” type, we can just inherent the “Person” type and make some adjustment based on our needs. Here we redefine the “talk” method to make a student talk in a different way.

class Student < Person

def talk
puts "I am a student. my name is "+@name+", age is "+@age.to_s
end
end

===Inability on handling large scale data===
Though it means more processing time, it is necessary for programmers to create composite type to handle the data whose length is too large or changing all the time. If we have a set or integers to maintain in memory, but the number of integers will change every second, it will be impossible if we only use primitive types to handle. But we can make use of the “Arraylist” type in Java or other composite types. With the “Arraylist”, the programmers do not need to pay attention to the storage in the memory or the space it takes. The compiler of Java will reallocate more space automatically for the Arraylist if more elements are putted. <ref>http://docs.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html Inability on handling large scale data</ref>

Example of the insert and sorting methods of the Arraylist type in Java:

ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.Sort();

===Limitation on size===

For the primitive data types in most programming languages, there are some limits of the size. For example we can put an integer between -(2^16) and (2^16)-1 into an “int” in Java. That will be enough for some most of the cases but definitely not all of them. For example, the primitive types are not enough for a scientific calculation if we need an accuracy on 10^-500. And a more extreme case is to calculate the last 100 numbers for the PI has a 100 million length.

For these situations, the programmers usually need to create a composite data type by themselves. They can even redefine the operators (“+”, “-”) to make the super-long float also can make addition, subtraction with ordinary operators instead of method calling. For more details to create a super long float please see reference.<ref>http://en.verysource.com/code/1285797_1/tlargefloat.h.html Limitation on size</ref>

===Not supporting utility methods===
Most of the object oriented languages have certain utility methods associated with non primitive data types that ease their use as compared to primitive data types that do not have such methods.<ref>http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html Not supporting utility methods</ref>.

An especially useful example is the method of parsing integers in a specified radix in Java (Integer.parseInt).

parseInt("1100110", 2); //returns 102
parseInt("-0", 10); //returns 0
parseInt("-FF", 16); //returns -255
parseInt("99", 8); //throws a NumberFormatException

From the above examples, it is obvious that “Integer” type not just support ordinary methods an integer should have (such as Integer.equals), but also some more utility methods which are helpful for the programmers.

In addition, for some data structure which only take object but not primitive type (such as Vector in Java), it is necessary to box a primitive data type to a corresponding object. For example if a programmer needs to make use of a vector to store some integer, it is necessary to box the ints and floats first:

Vector　v=new Vector();
int k=121;
v.addElemt(new Integer(k));

===Functionality===
Discussion of advantages and disadvantages should concerned the functionality you want to implement. For example if you want to operate a serials of int number. The performance of array may be better than int. <ref>http://cs.smith.edu/~thiebaut/ArtOfAssembly/CH05/CH05-2.html Composite datatypes</ref>

[[File:1w1.gif]]

To access an element of an array, you need a function that converts an array index into the address of the indexed element. For a single dimension array, this function is very simple. It is
Element_Address = Base_Address + ((Index - Initial_Index) * Element_Size)

However, If you use five primitive data type to implement the same function. It may cost more time for the cpu to search the address of each data.

== Conclusion ==
In a nutshell,composite data type is more likely to stand out the features of object-oriented language and be widely used. However,primitive data type would not disappear in a foreseeable future because of its advantage in performance and use. What's more, it bridges the gap between novice programmers and experienced programmers by making powerful features basic to the language and makes coding simpler. Dealing with primitive objects is easier at times. In brief, the primitive objects help to increase the productivity of the programmers.

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T02:26:37Z

Yliu63: /* Consistency */

'''Primitive objects in object-oriented languages'''

== Introduction ==

In any programming language, the [http://en.wikipedia.org/wiki/Data_type data type] refers to the class of data which contains specific type or range of values. Data types are used along with variables used in the program. The data type tells us what kind of values the variable can store, what is the range of the values and how much space the values take in memory etc.

The [http://en.wikipedia.org/wiki/Primitive_data_type primitive data types] refer to the built-in data types which are supported by the programming language. Often 'data types' and 'primitive data types' are used interchangeably. But not all data types are primitive. Programming languages have some non-primitive data types or derived data types which are provided by the language by making use of its primitive data types.

The common built-in data types or primitive data types are integers, floating point numbers, characters, strings and boolean.
* Integers - Integers represent the whole numbers which can be positive or negative or zero, e.g. 9999, 0, -25, etc.
* Floating point numbers - Floating point numbers represent the numbers which are fractions or contain floating-decimal points, e.g. -3.002, 2.5, 22.0, etc.
* Characters - Characters represent any single letter, number, space, punctuation mark, or symbol that can be typed on a computer, e.g. 'a', '9', ' ', '!' , '\n', etc.
* Strings - Strings represent the sequences of characters or simply any text, e.g. "Hello!", "9 am to 6 pm", etc.
* Booleans - Booleans represent the true or false values. Sometimes, instead of true and false, 1 and 0 are used to represent the boolean values.

Many [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming] languages provide support for primitive data types while some object-oriented programming languages provide support for primitive objects along with primitive types.

== Definition ==

Primitive objects refer to the objects of built-in classes which provide more functionality than the primitive types. Some object-oriented programming languages provide support for only primitive objects (i.e., in such languages all primitive types are objects).

Different object-oriented programming languages implement these primitive data types and primitive objects in a different manner.

== Primitive objects in different OO languages ==
=== Java ===

In [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java], there are 8 primitive types: boolean, char, byte, short, int, long, float, and double. <ref>http://www.cafeaulait.org/course/week2/02.html Java's Primitive Data Types</ref>

For each of these primitive types, Java provides [http://en.wikipedia.org/wiki/Primitive_wrapper_class wrapper classes] to create primitive objects which wrap the primitive data values. A wrapper not only contains the primitive data value, but it also defines properties and methods that can be used to manipulate that data. In Java, the primitive values are not implicitly converted to primitive objects. Instead, methods are provided for doing explicit conversion.
The primitive objects are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack heap] in memory while the variables containing primitive values are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack stack].<ref>http://www.informit.com/articles/article.aspx?p=31755&seqNum=8 Stack and Heap memory</ref>

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class!! Size
|-
| boolean || Boolean || 1-bit
|-
| char || Character || 16-bit
|-
| byte || Byte || 8-bit
|-
| short || Short || 16-bit
|-
| int || Integer || 32-bit
|-
| long || Long || 64-bit
|-
| float || Float || 32-bit
|-
| double || Double || 64-bit
|}

Example:
int i = 10;
int ii = 20;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I+II);
System.out.println(I.equals(II));

Output:
30
false

To find out if these wrapper classes are primitive or not, we can use the isPrimitive() method.

System.out.println(INTEGER.TYPE.isPrimitive());
System.out.println(BOOLEAN.TYPE.isPrimitive());

Output:
true
true

In Java, the comparison operations work in the same way on the primitive objects as well as any other class objects but different on the primitive types. The == operator when used on objects checks whether they refer to the same object but when used on variables of primitive types checks whether they contain the same value.<ref>http://leepoint.net/notes-java/data/expressions/22compareobjects.html Comparisons in Java</ref>

Example:
int i = 10;
int ii = 10;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I==II);
System.out.println(i==ii);

Output:
false
true

=== C# ===

[http://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29 C#] is a [http://en.wikipedia.org/wiki/Strong_typing strongly typed] language, where it is necessary to declare the data type of a variable and also be aware of the data type conversion. C# provides a significant number of primitive data types.<ref>http://condor.depaul.edu/sjost/ndp/notes/cs1/CSDatatypes.htm C# Primitive Datatypes</ref><ref>http://www.java2s.com/Tutorial/CSharp/0040__Data-Type/PrimitivesinC.htm Primitives in C#</ref>

Because C# represents all primitive data types as objects, it is possible to call an object method on a primitive data type. For example:

static void Main()
{
int x = 7;
object o = x;
System.Console.WriteLine(o.ToString());
}

Some data types (e.g. Decimal and String) can appear like primitives at first sight, but are actually not. So it is important to exercise caution before making such assumptions. To test whether a particular type is a primitive or not you can use the property Type.IsPrimitive.

Consider the following example:

if (t.IsPrimitive) // where t is the type
{
// Is Primitive
} else if (t == typeof(Decimal))
{
// Is Decimal
} else if (t == typeof(String))
{
// Is String
} else
{
// Other type
}

=== JavaScript ===

There are 5 primitive data types in [http://en.wikipedia.org/wiki/JavaScript JavaScript]: string, number, boolean, null and undefined. <ref>http://oreilly.com/javascript/excerpts/learning-javascript/javascript-datatypes-variables.html JavaScript Data Types and Variables</ref>

For string, number and boolean values, there are corresponding classes just like in Java to create primitive objects which wrap the primitive values.

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class
|-
| string || String
|-
| number|| Number
|-
| boolean || Boolean
|}

In JavaScript, the primitive value is implicitly converted to a primitive object whenever someone tries to access a property or invoke a method on the primitive value and the primitive object is used in place of the primitive value. Since the object contains properties and methods, the use of primitive value as an object succeeds. After the property is accessed or the method is processed, the primitive object is no longer needed and hence discarded. The same is true for the other primitive types and their corresponding primitive objects.

Example:

var upperCaseString = "APPLE";
var lowerCaseString = upperCaseString.toLowerCase(); // assigns string "apple" to lowerCaseString
var s = "Hello"
var len = s.length; // assigns value 5 to len

=== Ruby ===

Since [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is a [http://www.jvoegele.com/software/langcomp.html pure object oriented] language, everything in Ruby is an object. Hence, all primitive types such as integers, floating point numbers, strings, are objects of a built-in class.<ref>http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html Classes in Ruby</ref>
All integers are primitive objects of either class [http://corelib.rubyonrails.org/classes/Fixnum.html Fixnum] or [http://corelib.rubyonrails.org/classes/Bignum.html Bignum]. A numeric literal with a decimal point and/or an exponent is a primitive object of [http://corelib.rubyonrails.org/classes/Float.html Float]. Single quoted literals and double quoted literals are primitive objects of [http://corelib.rubyonrails.org/classes/String.html String].

Example:

puts 10.class
puts 7.45.class
puts 'hi'.class
puts "hello".class

Output:

Fixnum
Float
String
String

This indicates that 10 is converted into an object of type Fixnum, 7.45 is converted into an object of type Float, 'hi' and "hello" are both converted into an object of type String.

Since all primitive types in Ruby are objects, we should be able to call methods of the Object class on them. Let us demonstrate the same for integer and float using the following example:

a=10
puts a.to_f
b=20.5
puts b.to_i

Output:
10.0
20

== Advantages of primitives ==

Advantages that use of primitive data type offers are as follows:
===Consistency===
Many ideas of Java originate in C and in C++, objects and primitive type also co-exist. When object-oriented constructs were grafted onto the C language, C’s data types remained as is. The motivation behind this is that Bjarne Stroustrup, C++’s designer, wanted to be as consistent as possible with the base C language, hoping to capitalize on programmers’ pre-C++ knowledge.
<ref>http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Primitive Types Considered Harmful</ref>

===Simplicity===
It is simple and intuitive to use primitive data type in basic utility.

Example:

1. Recurring number in a loop.(C++)

for(int i=0;i<10;i++)

2. Temp variables that record only one or two data.

===Performance===

====Time====
Processing primitive data type operation would be faster than processing composite data type in most cases. There are several reasons result in this differences.
*Hardware processing discrepancy
Many primitive data operations (like integer addition) can be performed as a single machine instruction while processing of composite data type would be transformed to a combination of primitive data types. eg. Some processors offer specific instructions to process sequences of characters with a single instruction.

Example:

[http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Difference in data fetching between primitive data and composite data in Java]

*Allocating and Garbage collection overhead for composite data type<ref>http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Performance_implications Garbage collection</ref><ref>http://www.ibm.com/developerworks/java/library/j-jtp01274/index.html Java theory and practice: Garbage collection and performance</ref>
There are many initialization operations for composite data type that will generate high overheads for example boxing and unboxing, constructors and destructors.Composite data type like class will also have garbage collection overheads that may be beyond the control of the programmer and can sometimes lead to performance problems. For example, commonly used stop-the-world garbage collectors, which pause program execution at arbitrary times, may make garbage collection inappropriate for some [http://en.wikipedia.org/wiki/Embedded_system embedded systems], high-performance [http://en.wikipedia.org/wiki/Server_(computing) server] software, and applications with [http://en.wikipedia.org/wiki/Real-time_computing real-time] needs.In the early days of Java technology, allocating objects got a high overheads. There were lots of articles advising developers to avoid creating temporary objects unnecessarily because allocation (and the corresponding garbage-collection overhead) was expensive. Although the costs have been greatly reduced nowadays. It still much slower than primitive data type which don’t have such troubles.

Example:

public class Test{
double dur1,dur2;
int N=100000000;
public void test1()
{
int a=1,b=1;
long startTime1 = System.currentTimeMillis();
for(int i=0;i<N;i++){
a=a+b;
}
long endTime1 = System.currentTimeMillis();
System.out.println(endTime1-startTime1);
}
public void test2(){
Integer c=new Integer(1);
Integer d=new Integer(1);
long startTime2 = System.currentTimeMillis();
for(int i=0;i<N;i++){
c=c+d;
}
long endTime2 = System.currentTimeMillis();
System.out.println(endTime2-startTime2)
}

Average execution time for test1 is: 1 mm

Average execution time for test2 is: 702mm

(test case number: 1000 times )

====Space====
Composite data type will cost more memory space than primitive data type in general. The reason is not only for the overheads generated by constructors, destructors etc, but also the feature of data alignment. <ref>http://en.wikipedia.org/wiki/Data_structure_alignment#Data_structure_padding Data structure alignment</ref>

Example of data alignment （C++）
struct compose
{
char name;
int a;
int b;
}

We all know the size of char is 1 byte, the size of int is 4 bytes. But the size of the struct compose as shown above is 12 bytes but not 9 bytes.

== Disdvantages of primitives ==

The various disadvantages of using the primitive data types are as follows:

===Cannot be extended===
We can use class or array to express the intricate data or functional structure. And programmers can create subtypes, modify their operations and even redefine them. In addition with the feature of class, programmers can make their variables unchangeable to any code outside the class, or make the implementation hidden to other code with call the methods. That means with composite data types, it will be more convenient for the programmers to handle sophisticated data and also make the code easier to maintain.

We can create a Person type in RUBY. We defined a “talk” method to make a Person can talk about himself. We also hope to only make the variable “motherland” changeable by the code outside this class.

Example：

class Person

def initialize( name, age=18 )
@name = name
@age = age
@motherland = "US"
end

def talk
puts "my name is "+@name+", age is "+@age.to_s
if @motherland == "US"
puts "I\'m American."
else
puts "I\'m International."
end
end
attr_writer :motherland
end

Later when we need to create a “Student” type, we can just inherent the “Person” type and make some adjustment based on our needs. Here we redefine the “talk” method to make a student talk in a different way.

class Student < Person

def talk
puts "I am a student. my name is "+@name+", age is "+@age.to_s
end
end

===Uncertainty===
Though it means more processing time, it is necessary for programmers to create composite type to handle the data whose length is too large or changing all the time. If we have a set or integers to maintain in memory, but the number of integers will change every minute, it will be impossible if we only use primitive types to handle. But we can make use of the “Arraylist” type in Java or other composite types. With the “Arraylist”, the programmers do not need to pay attention to the storage in the memory or the space it takes. The compiler of Java will reallocate more space automatically for the Arraylist if more elements are putted. <ref>http://docs.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html uncertainty of array</ref>

Here is an example for the insert and sorting methods of the Arraylist type in Java:

ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.Sort();

===Limitation===

For the primitive data types in most programming languages, there are some limits of the length. For example we can put an integer between -(2^16) and (2^16)-1 into an “int” in Java. That will be enough for some most of the cases but definitely not all of them. For example, the primitive types are not able for a scientific calculation if we need an accuracy on 10^-500. And a more extreme case is to calculate the last 100 numbers for the PI has a 100 million length.<ref>http://en.verysource.com/code/1285797_1/tlargefloat.h.html limitation of primitive</ref>

For these situations, the programmers usually need to create a composite data type by themselves. They can even redefine the operators (“+”, “-”) to make the super-long float also can make addition, subtraction with ordinary operators instead of method calling. For more details to create a super long float please see reference.

===Cannot simplify the utility function associated with non primitive data types===

Most of the object oriented languages have certain utility functions associated with non primitive data types that ease their use as compared to primitive data types that do not have such functions. An especially useful example is the method of parsing integers in a specified radix in Java (Integer.parseInt). <ref>http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html utility function associated with non primitive data types</ref>

parseInt("1100110", 2); //returns 102
parseInt("-0", 10); //returns 0
parseInt("-FF", 16); //returns -255
parseInt("99", 8); //throws a NumberFormatException

From the above examples, it is obvious that “Integer” type not just support ordinary methods an integer should have (such as Integer.equals), but also some more utility methods which are helpful for the programmers.

In addition, for some data structure which only take object but not primitive type (such as Vector in Java), it is necessary to box a primitive data type to a corresponding object. For example if a programmer needs to make use of a vector to store some integer, it is necessary to box the int first:

Vector　v=new Vector();
int k=121;
v.addElemt(new Integer(k));

===Functionality===
Discussion of advantages and disadvantages should concerned the functionality you want to implement. For example if you want to operate a serials of int number. The performance of array may be better than int. <ref>http://cs.smith.edu/~thiebaut/ArtOfAssembly/CH05/CH05-2.html composite datatypes</ref>

[[File:1w1.gif]]

To access an element of an array, you need a function that converts an array index into the address of the indexed element. For a single dimension array, this function is very simple. It is
Element_Address = Base_Address + ((Index - Initial_Index) * Element_Size)
However, If you use five primitive data type to implement the same function. It may cost more time for the cpu to search the address of each data.

== Conclusion ==

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T02:25:39Z

Yliu63: /* Functionality */

'''Primitive objects in object-oriented languages'''

== Introduction ==

In any programming language, the [http://en.wikipedia.org/wiki/Data_type data type] refers to the class of data which contains specific type or range of values. Data types are used along with variables used in the program. The data type tells us what kind of values the variable can store, what is the range of the values and how much space the values take in memory etc.

The [http://en.wikipedia.org/wiki/Primitive_data_type primitive data types] refer to the built-in data types which are supported by the programming language. Often 'data types' and 'primitive data types' are used interchangeably. But not all data types are primitive. Programming languages have some non-primitive data types or derived data types which are provided by the language by making use of its primitive data types.

The common built-in data types or primitive data types are integers, floating point numbers, characters, strings and boolean.
* Integers - Integers represent the whole numbers which can be positive or negative or zero, e.g. 9999, 0, -25, etc.
* Floating point numbers - Floating point numbers represent the numbers which are fractions or contain floating-decimal points, e.g. -3.002, 2.5, 22.0, etc.
* Characters - Characters represent any single letter, number, space, punctuation mark, or symbol that can be typed on a computer, e.g. 'a', '9', ' ', '!' , '\n', etc.
* Strings - Strings represent the sequences of characters or simply any text, e.g. "Hello!", "9 am to 6 pm", etc.
* Booleans - Booleans represent the true or false values. Sometimes, instead of true and false, 1 and 0 are used to represent the boolean values.

Many [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming] languages provide support for primitive data types while some object-oriented programming languages provide support for primitive objects along with primitive types.

== Definition ==

Primitive objects refer to the objects of built-in classes which provide more functionality than the primitive types. Some object-oriented programming languages provide support for only primitive objects (i.e., in such languages all primitive types are objects).

Different object-oriented programming languages implement these primitive data types and primitive objects in a different manner.

== Primitive objects in different OO languages ==
=== Java ===

In [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java], there are 8 primitive types: boolean, char, byte, short, int, long, float, and double. <ref>http://www.cafeaulait.org/course/week2/02.html Java's Primitive Data Types</ref>

For each of these primitive types, Java provides [http://en.wikipedia.org/wiki/Primitive_wrapper_class wrapper classes] to create primitive objects which wrap the primitive data values. A wrapper not only contains the primitive data value, but it also defines properties and methods that can be used to manipulate that data. In Java, the primitive values are not implicitly converted to primitive objects. Instead, methods are provided for doing explicit conversion.
The primitive objects are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack heap] in memory while the variables containing primitive values are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack stack].<ref>http://www.informit.com/articles/article.aspx?p=31755&seqNum=8 Stack and Heap memory</ref>

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class!! Size
|-
| boolean || Boolean || 1-bit
|-
| char || Character || 16-bit
|-
| byte || Byte || 8-bit
|-
| short || Short || 16-bit
|-
| int || Integer || 32-bit
|-
| long || Long || 64-bit
|-
| float || Float || 32-bit
|-
| double || Double || 64-bit
|}

Example:
int i = 10;
int ii = 20;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I+II);
System.out.println(I.equals(II));

Output:
30
false

To find out if these wrapper classes are primitive or not, we can use the isPrimitive() method.

System.out.println(INTEGER.TYPE.isPrimitive());
System.out.println(BOOLEAN.TYPE.isPrimitive());

Output:
true
true

In Java, the comparison operations work in the same way on the primitive objects as well as any other class objects but different on the primitive types. The == operator when used on objects checks whether they refer to the same object but when used on variables of primitive types checks whether they contain the same value.<ref>http://leepoint.net/notes-java/data/expressions/22compareobjects.html Comparisons in Java</ref>

Example:
int i = 10;
int ii = 10;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I==II);
System.out.println(i==ii);

Output:
false
true

=== C# ===

[http://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29 C#] is a [http://en.wikipedia.org/wiki/Strong_typing strongly typed] language, where it is necessary to declare the data type of a variable and also be aware of the data type conversion. C# provides a significant number of primitive data types.<ref>http://condor.depaul.edu/sjost/ndp/notes/cs1/CSDatatypes.htm C# Primitive Datatypes</ref><ref>http://www.java2s.com/Tutorial/CSharp/0040__Data-Type/PrimitivesinC.htm Primitives in C#</ref>

Because C# represents all primitive data types as objects, it is possible to call an object method on a primitive data type. For example:

static void Main()
{
int x = 7;
object o = x;
System.Console.WriteLine(o.ToString());
}

Some data types (e.g. Decimal and String) can appear like primitives at first sight, but are actually not. So it is important to exercise caution before making such assumptions. To test whether a particular type is a primitive or not you can use the property Type.IsPrimitive.

Consider the following example:

if (t.IsPrimitive) // where t is the type
{
// Is Primitive
} else if (t == typeof(Decimal))
{
// Is Decimal
} else if (t == typeof(String))
{
// Is String
} else
{
// Other type
}

=== JavaScript ===

There are 5 primitive data types in [http://en.wikipedia.org/wiki/JavaScript JavaScript]: string, number, boolean, null and undefined. <ref>http://oreilly.com/javascript/excerpts/learning-javascript/javascript-datatypes-variables.html JavaScript Data Types and Variables</ref>

For string, number and boolean values, there are corresponding classes just like in Java to create primitive objects which wrap the primitive values.

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class
|-
| string || String
|-
| number|| Number
|-
| boolean || Boolean
|}

In JavaScript, the primitive value is implicitly converted to a primitive object whenever someone tries to access a property or invoke a method on the primitive value and the primitive object is used in place of the primitive value. Since the object contains properties and methods, the use of primitive value as an object succeeds. After the property is accessed or the method is processed, the primitive object is no longer needed and hence discarded. The same is true for the other primitive types and their corresponding primitive objects.

Example:

var upperCaseString = "APPLE";
var lowerCaseString = upperCaseString.toLowerCase(); // assigns string "apple" to lowerCaseString
var s = "Hello"
var len = s.length; // assigns value 5 to len

=== Ruby ===

Since [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is a [http://www.jvoegele.com/software/langcomp.html pure object oriented] language, everything in Ruby is an object. Hence, all primitive types such as integers, floating point numbers, strings, are objects of a built-in class.<ref>http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html Classes in Ruby</ref>
All integers are primitive objects of either class [http://corelib.rubyonrails.org/classes/Fixnum.html Fixnum] or [http://corelib.rubyonrails.org/classes/Bignum.html Bignum]. A numeric literal with a decimal point and/or an exponent is a primitive object of [http://corelib.rubyonrails.org/classes/Float.html Float]. Single quoted literals and double quoted literals are primitive objects of [http://corelib.rubyonrails.org/classes/String.html String].

Example:

puts 10.class
puts 7.45.class
puts 'hi'.class
puts "hello".class

Output:

Fixnum
Float
String
String

This indicates that 10 is converted into an object of type Fixnum, 7.45 is converted into an object of type Float, 'hi' and "hello" are both converted into an object of type String.

Since all primitive types in Ruby are objects, we should be able to call methods of the Object class on them. Let us demonstrate the same for integer and float using the following example:

a=10
puts a.to_f
b=20.5
puts b.to_i

Output:
10.0
20

== Advantages of primitives ==

Advantages that use of primitive data type offers are as follows:
===Consistency===
Many of Java’s ideas originate in C and in C++, objects and primitive type also co-exist. When object-oriented constructs were grafted onto the C language, C’s data types remained as is. The motivation behind this is that Bjarne Stroustrup, C++’s designer, wanted to be as consistent as possible with the base C language, hoping to capitalize on programmers’ pre-C++ knowledge.
<ref>http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Primitive Types Considered Harmful</ref>

===Simplicity===
It is simple and intuitive to use primitive data type in basic utility.

Example:

1. Recurring number in a loop.(C++)

for(int i=0;i<10;i++)

2. Temp variables that record only one or two data.

===Performance===

====Time====
Processing primitive data type operation would be faster than processing composite data type in most cases. There are several reasons result in this differences.
*Hardware processing discrepancy
Many primitive data operations (like integer addition) can be performed as a single machine instruction while processing of composite data type would be transformed to a combination of primitive data types. eg. Some processors offer specific instructions to process sequences of characters with a single instruction.

Example:

[http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Difference in data fetching between primitive data and composite data in Java]

*Allocating and Garbage collection overhead for composite data type<ref>http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Performance_implications Garbage collection</ref><ref>http://www.ibm.com/developerworks/java/library/j-jtp01274/index.html Java theory and practice: Garbage collection and performance</ref>
There are many initialization operations for composite data type that will generate high overheads for example boxing and unboxing, constructors and destructors.Composite data type like class will also have garbage collection overheads that may be beyond the control of the programmer and can sometimes lead to performance problems. For example, commonly used stop-the-world garbage collectors, which pause program execution at arbitrary times, may make garbage collection inappropriate for some [http://en.wikipedia.org/wiki/Embedded_system embedded systems], high-performance [http://en.wikipedia.org/wiki/Server_(computing) server] software, and applications with [http://en.wikipedia.org/wiki/Real-time_computing real-time] needs.In the early days of Java technology, allocating objects got a high overheads. There were lots of articles advising developers to avoid creating temporary objects unnecessarily because allocation (and the corresponding garbage-collection overhead) was expensive. Although the costs have been greatly reduced nowadays. It still much slower than primitive data type which don’t have such troubles.

Example:

public class Test{
double dur1,dur2;
int N=100000000;
public void test1()
{
int a=1,b=1;
long startTime1 = System.currentTimeMillis();
for(int i=0;i<N;i++){
a=a+b;
}
long endTime1 = System.currentTimeMillis();
System.out.println(endTime1-startTime1);
}
public void test2(){
Integer c=new Integer(1);
Integer d=new Integer(1);
long startTime2 = System.currentTimeMillis();
for(int i=0;i<N;i++){
c=c+d;
}
long endTime2 = System.currentTimeMillis();
System.out.println(endTime2-startTime2)
}

Average execution time for test1 is: 1 mm

Average execution time for test2 is: 702mm

(test case number: 1000 times )

====Space====
Composite data type will cost more memory space than primitive data type in general. The reason is not only for the overheads generated by constructors, destructors etc, but also the feature of data alignment. <ref>http://en.wikipedia.org/wiki/Data_structure_alignment#Data_structure_padding Data structure alignment</ref>

Example of data alignment （C++）
struct compose
{
char name;
int a;
int b;
}

We all know the size of char is 1 byte, the size of int is 4 bytes. But the size of the struct compose as shown above is 12 bytes but not 9 bytes.

== Disdvantages of primitives ==

The various disadvantages of using the primitive data types are as follows:

===Cannot be extended===
We can use class or array to express the intricate data or functional structure. And programmers can create subtypes, modify their operations and even redefine them. In addition with the feature of class, programmers can make their variables unchangeable to any code outside the class, or make the implementation hidden to other code with call the methods. That means with composite data types, it will be more convenient for the programmers to handle sophisticated data and also make the code easier to maintain.

We can create a Person type in RUBY. We defined a “talk” method to make a Person can talk about himself. We also hope to only make the variable “motherland” changeable by the code outside this class.

Example：

class Person

def initialize( name, age=18 )
@name = name
@age = age
@motherland = "US"
end

def talk
puts "my name is "+@name+", age is "+@age.to_s
if @motherland == "US"
puts "I\'m American."
else
puts "I\'m International."
end
end
attr_writer :motherland
end

Later when we need to create a “Student” type, we can just inherent the “Person” type and make some adjustment based on our needs. Here we redefine the “talk” method to make a student talk in a different way.

class Student < Person

def talk
puts "I am a student. my name is "+@name+", age is "+@age.to_s
end
end

===Uncertainty===
Though it means more processing time, it is necessary for programmers to create composite type to handle the data whose length is too large or changing all the time. If we have a set or integers to maintain in memory, but the number of integers will change every minute, it will be impossible if we only use primitive types to handle. But we can make use of the “Arraylist” type in Java or other composite types. With the “Arraylist”, the programmers do not need to pay attention to the storage in the memory or the space it takes. The compiler of Java will reallocate more space automatically for the Arraylist if more elements are putted. <ref>http://docs.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html uncertainty of array</ref>

Here is an example for the insert and sorting methods of the Arraylist type in Java:

ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.Sort();

===Limitation===

For the primitive data types in most programming languages, there are some limits of the length. For example we can put an integer between -(2^16) and (2^16)-1 into an “int” in Java. That will be enough for some most of the cases but definitely not all of them. For example, the primitive types are not able for a scientific calculation if we need an accuracy on 10^-500. And a more extreme case is to calculate the last 100 numbers for the PI has a 100 million length.<ref>http://en.verysource.com/code/1285797_1/tlargefloat.h.html limitation of primitive</ref>

For these situations, the programmers usually need to create a composite data type by themselves. They can even redefine the operators (“+”, “-”) to make the super-long float also can make addition, subtraction with ordinary operators instead of method calling. For more details to create a super long float please see reference.

===Cannot simplify the utility function associated with non primitive data types===

Most of the object oriented languages have certain utility functions associated with non primitive data types that ease their use as compared to primitive data types that do not have such functions. An especially useful example is the method of parsing integers in a specified radix in Java (Integer.parseInt). <ref>http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html utility function associated with non primitive data types</ref>

parseInt("1100110", 2); //returns 102
parseInt("-0", 10); //returns 0
parseInt("-FF", 16); //returns -255
parseInt("99", 8); //throws a NumberFormatException

From the above examples, it is obvious that “Integer” type not just support ordinary methods an integer should have (such as Integer.equals), but also some more utility methods which are helpful for the programmers.

In addition, for some data structure which only take object but not primitive type (such as Vector in Java), it is necessary to box a primitive data type to a corresponding object. For example if a programmer needs to make use of a vector to store some integer, it is necessary to box the int first:

Vector　v=new Vector();
int k=121;
v.addElemt(new Integer(k));

===Functionality===
Discussion of advantages and disadvantages should concerned the functionality you want to implement. For example if you want to operate a serials of int number. The performance of array may be better than int. <ref>http://cs.smith.edu/~thiebaut/ArtOfAssembly/CH05/CH05-2.html composite datatypes</ref>

[[File:1w1.gif]]

To access an element of an array, you need a function that converts an array index into the address of the indexed element. For a single dimension array, this function is very simple. It is
Element_Address = Base_Address + ((Index - Initial_Index) * Element_Size)
However, If you use five primitive data type to implement the same function. It may cost more time for the cpu to search the address of each data.

== Conclusion ==

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T02:25:07Z

Yliu63: /* Disdvantages of primitives */

'''Primitive objects in object-oriented languages'''

== Introduction ==

In any programming language, the [http://en.wikipedia.org/wiki/Data_type data type] refers to the class of data which contains specific type or range of values. Data types are used along with variables used in the program. The data type tells us what kind of values the variable can store, what is the range of the values and how much space the values take in memory etc.

The [http://en.wikipedia.org/wiki/Primitive_data_type primitive data types] refer to the built-in data types which are supported by the programming language. Often 'data types' and 'primitive data types' are used interchangeably. But not all data types are primitive. Programming languages have some non-primitive data types or derived data types which are provided by the language by making use of its primitive data types.

The common built-in data types or primitive data types are integers, floating point numbers, characters, strings and boolean.
* Integers - Integers represent the whole numbers which can be positive or negative or zero, e.g. 9999, 0, -25, etc.
* Floating point numbers - Floating point numbers represent the numbers which are fractions or contain floating-decimal points, e.g. -3.002, 2.5, 22.0, etc.
* Characters - Characters represent any single letter, number, space, punctuation mark, or symbol that can be typed on a computer, e.g. 'a', '9', ' ', '!' , '\n', etc.
* Strings - Strings represent the sequences of characters or simply any text, e.g. "Hello!", "9 am to 6 pm", etc.
* Booleans - Booleans represent the true or false values. Sometimes, instead of true and false, 1 and 0 are used to represent the boolean values.

Many [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming] languages provide support for primitive data types while some object-oriented programming languages provide support for primitive objects along with primitive types.

== Definition ==

Primitive objects refer to the objects of built-in classes which provide more functionality than the primitive types. Some object-oriented programming languages provide support for only primitive objects (i.e., in such languages all primitive types are objects).

Different object-oriented programming languages implement these primitive data types and primitive objects in a different manner.

== Primitive objects in different OO languages ==
=== Java ===

In [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java], there are 8 primitive types: boolean, char, byte, short, int, long, float, and double. <ref>http://www.cafeaulait.org/course/week2/02.html Java's Primitive Data Types</ref>

For each of these primitive types, Java provides [http://en.wikipedia.org/wiki/Primitive_wrapper_class wrapper classes] to create primitive objects which wrap the primitive data values. A wrapper not only contains the primitive data value, but it also defines properties and methods that can be used to manipulate that data. In Java, the primitive values are not implicitly converted to primitive objects. Instead, methods are provided for doing explicit conversion.
The primitive objects are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack heap] in memory while the variables containing primitive values are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack stack].<ref>http://www.informit.com/articles/article.aspx?p=31755&seqNum=8 Stack and Heap memory</ref>

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class!! Size
|-
| boolean || Boolean || 1-bit
|-
| char || Character || 16-bit
|-
| byte || Byte || 8-bit
|-
| short || Short || 16-bit
|-
| int || Integer || 32-bit
|-
| long || Long || 64-bit
|-
| float || Float || 32-bit
|-
| double || Double || 64-bit
|}

Example:
int i = 10;
int ii = 20;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I+II);
System.out.println(I.equals(II));

Output:
30
false

To find out if these wrapper classes are primitive or not, we can use the isPrimitive() method.

System.out.println(INTEGER.TYPE.isPrimitive());
System.out.println(BOOLEAN.TYPE.isPrimitive());

Output:
true
true

In Java, the comparison operations work in the same way on the primitive objects as well as any other class objects but different on the primitive types. The == operator when used on objects checks whether they refer to the same object but when used on variables of primitive types checks whether they contain the same value.<ref>http://leepoint.net/notes-java/data/expressions/22compareobjects.html Comparisons in Java</ref>

Example:
int i = 10;
int ii = 10;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I==II);
System.out.println(i==ii);

Output:
false
true

=== C# ===

[http://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29 C#] is a [http://en.wikipedia.org/wiki/Strong_typing strongly typed] language, where it is necessary to declare the data type of a variable and also be aware of the data type conversion. C# provides a significant number of primitive data types.<ref>http://condor.depaul.edu/sjost/ndp/notes/cs1/CSDatatypes.htm C# Primitive Datatypes</ref><ref>http://www.java2s.com/Tutorial/CSharp/0040__Data-Type/PrimitivesinC.htm Primitives in C#</ref>

Because C# represents all primitive data types as objects, it is possible to call an object method on a primitive data type. For example:

static void Main()
{
int x = 7;
object o = x;
System.Console.WriteLine(o.ToString());
}

Some data types (e.g. Decimal and String) can appear like primitives at first sight, but are actually not. So it is important to exercise caution before making such assumptions. To test whether a particular type is a primitive or not you can use the property Type.IsPrimitive.

Consider the following example:

if (t.IsPrimitive) // where t is the type
{
// Is Primitive
} else if (t == typeof(Decimal))
{
// Is Decimal
} else if (t == typeof(String))
{
// Is String
} else
{
// Other type
}

=== JavaScript ===

There are 5 primitive data types in [http://en.wikipedia.org/wiki/JavaScript JavaScript]: string, number, boolean, null and undefined. <ref>http://oreilly.com/javascript/excerpts/learning-javascript/javascript-datatypes-variables.html JavaScript Data Types and Variables</ref>

For string, number and boolean values, there are corresponding classes just like in Java to create primitive objects which wrap the primitive values.

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class
|-
| string || String
|-
| number|| Number
|-
| boolean || Boolean
|}

In JavaScript, the primitive value is implicitly converted to a primitive object whenever someone tries to access a property or invoke a method on the primitive value and the primitive object is used in place of the primitive value. Since the object contains properties and methods, the use of primitive value as an object succeeds. After the property is accessed or the method is processed, the primitive object is no longer needed and hence discarded. The same is true for the other primitive types and their corresponding primitive objects.

Example:

var upperCaseString = "APPLE";
var lowerCaseString = upperCaseString.toLowerCase(); // assigns string "apple" to lowerCaseString
var s = "Hello"
var len = s.length; // assigns value 5 to len

=== Ruby ===

Since [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is a [http://www.jvoegele.com/software/langcomp.html pure object oriented] language, everything in Ruby is an object. Hence, all primitive types such as integers, floating point numbers, strings, are objects of a built-in class.<ref>http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html Classes in Ruby</ref>
All integers are primitive objects of either class [http://corelib.rubyonrails.org/classes/Fixnum.html Fixnum] or [http://corelib.rubyonrails.org/classes/Bignum.html Bignum]. A numeric literal with a decimal point and/or an exponent is a primitive object of [http://corelib.rubyonrails.org/classes/Float.html Float]. Single quoted literals and double quoted literals are primitive objects of [http://corelib.rubyonrails.org/classes/String.html String].

Example:

puts 10.class
puts 7.45.class
puts 'hi'.class
puts "hello".class

Output:

Fixnum
Float
String
String

This indicates that 10 is converted into an object of type Fixnum, 7.45 is converted into an object of type Float, 'hi' and "hello" are both converted into an object of type String.

Since all primitive types in Ruby are objects, we should be able to call methods of the Object class on them. Let us demonstrate the same for integer and float using the following example:

a=10
puts a.to_f
b=20.5
puts b.to_i

Output:
10.0
20

== Advantages of primitives ==

Advantages that use of primitive data type offers are as follows:
===Consistency===
Many of Java’s ideas originate in C and in C++, objects and primitive type also co-exist. When object-oriented constructs were grafted onto the C language, C’s data types remained as is. The motivation behind this is that Bjarne Stroustrup, C++’s designer, wanted to be as consistent as possible with the base C language, hoping to capitalize on programmers’ pre-C++ knowledge.
<ref>http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Primitive Types Considered Harmful</ref>

===Simplicity===
It is simple and intuitive to use primitive data type in basic utility.

Example:

1. Recurring number in a loop.(C++)

for(int i=0;i<10;i++)

2. Temp variables that record only one or two data.

===Performance===

====Time====
Processing primitive data type operation would be faster than processing composite data type in most cases. There are several reasons result in this differences.
*Hardware processing discrepancy
Many primitive data operations (like integer addition) can be performed as a single machine instruction while processing of composite data type would be transformed to a combination of primitive data types. eg. Some processors offer specific instructions to process sequences of characters with a single instruction.

Example:

[http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Difference in data fetching between primitive data and composite data in Java]

*Allocating and Garbage collection overhead for composite data type<ref>http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Performance_implications Garbage collection</ref><ref>http://www.ibm.com/developerworks/java/library/j-jtp01274/index.html Java theory and practice: Garbage collection and performance</ref>
There are many initialization operations for composite data type that will generate high overheads for example boxing and unboxing, constructors and destructors.Composite data type like class will also have garbage collection overheads that may be beyond the control of the programmer and can sometimes lead to performance problems. For example, commonly used stop-the-world garbage collectors, which pause program execution at arbitrary times, may make garbage collection inappropriate for some [http://en.wikipedia.org/wiki/Embedded_system embedded systems], high-performance [http://en.wikipedia.org/wiki/Server_(computing) server] software, and applications with [http://en.wikipedia.org/wiki/Real-time_computing real-time] needs.In the early days of Java technology, allocating objects got a high overheads. There were lots of articles advising developers to avoid creating temporary objects unnecessarily because allocation (and the corresponding garbage-collection overhead) was expensive. Although the costs have been greatly reduced nowadays. It still much slower than primitive data type which don’t have such troubles.

Example:

public class Test{
double dur1,dur2;
int N=100000000;
public void test1()
{
int a=1,b=1;
long startTime1 = System.currentTimeMillis();
for(int i=0;i<N;i++){
a=a+b;
}
long endTime1 = System.currentTimeMillis();
System.out.println(endTime1-startTime1);
}
public void test2(){
Integer c=new Integer(1);
Integer d=new Integer(1);
long startTime2 = System.currentTimeMillis();
for(int i=0;i<N;i++){
c=c+d;
}
long endTime2 = System.currentTimeMillis();
System.out.println(endTime2-startTime2)
}

Average execution time for test1 is: 1 mm

Average execution time for test2 is: 702mm

(test case number: 1000 times )

====Space====
Composite data type will cost more memory space than primitive data type in general. The reason is not only for the overheads generated by constructors, destructors etc, but also the feature of data alignment. <ref>http://en.wikipedia.org/wiki/Data_structure_alignment#Data_structure_padding Data structure alignment</ref>

Example of data alignment （C++）
struct compose
{
char name;
int a;
int b;
}

We all know the size of char is 1 byte, the size of int is 4 bytes. But the size of the struct compose as shown above is 12 bytes but not 9 bytes.

== Disdvantages of primitives ==

The various disadvantages of using the primitive data types are as follows:

===Cannot be extended===
We can use class or array to express the intricate data or functional structure. And programmers can create subtypes, modify their operations and even redefine them. In addition with the feature of class, programmers can make their variables unchangeable to any code outside the class, or make the implementation hidden to other code with call the methods. That means with composite data types, it will be more convenient for the programmers to handle sophisticated data and also make the code easier to maintain.

We can create a Person type in RUBY. We defined a “talk” method to make a Person can talk about himself. We also hope to only make the variable “motherland” changeable by the code outside this class.

Example：

class Person

def initialize( name, age=18 )
@name = name
@age = age
@motherland = "US"
end

def talk
puts "my name is "+@name+", age is "+@age.to_s
if @motherland == "US"
puts "I\'m American."
else
puts "I\'m International."
end
end
attr_writer :motherland
end

Later when we need to create a “Student” type, we can just inherent the “Person” type and make some adjustment based on our needs. Here we redefine the “talk” method to make a student talk in a different way.

class Student < Person

def talk
puts "I am a student. my name is "+@name+", age is "+@age.to_s
end
end

===Uncertainty===
Though it means more processing time, it is necessary for programmers to create composite type to handle the data whose length is too large or changing all the time. If we have a set or integers to maintain in memory, but the number of integers will change every minute, it will be impossible if we only use primitive types to handle. But we can make use of the “Arraylist” type in Java or other composite types. With the “Arraylist”, the programmers do not need to pay attention to the storage in the memory or the space it takes. The compiler of Java will reallocate more space automatically for the Arraylist if more elements are putted. <ref>http://docs.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html uncertainty of array</ref>

Here is an example for the insert and sorting methods of the Arraylist type in Java:

ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.Sort();

===Limitation===

For the primitive data types in most programming languages, there are some limits of the length. For example we can put an integer between -(2^16) and (2^16)-1 into an “int” in Java. That will be enough for some most of the cases but definitely not all of them. For example, the primitive types are not able for a scientific calculation if we need an accuracy on 10^-500. And a more extreme case is to calculate the last 100 numbers for the PI has a 100 million length.<ref>http://en.verysource.com/code/1285797_1/tlargefloat.h.html limitation of primitive</ref>

For these situations, the programmers usually need to create a composite data type by themselves. They can even redefine the operators (“+”, “-”) to make the super-long float also can make addition, subtraction with ordinary operators instead of method calling. For more details to create a super long float please see reference.

===Cannot simplify the utility function associated with non primitive data types===

Most of the object oriented languages have certain utility functions associated with non primitive data types that ease their use as compared to primitive data types that do not have such functions. An especially useful example is the method of parsing integers in a specified radix in Java (Integer.parseInt). <ref>http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html utility function associated with non primitive data types</ref>

parseInt("1100110", 2); //returns 102
parseInt("-0", 10); //returns 0
parseInt("-FF", 16); //returns -255
parseInt("99", 8); //throws a NumberFormatException

From the above examples, it is obvious that “Integer” type not just support ordinary methods an integer should have (such as Integer.equals), but also some more utility methods which are helpful for the programmers.

In addition, for some data structure which only take object but not primitive type (such as Vector in Java), it is necessary to box a primitive data type to a corresponding object. For example if a programmer needs to make use of a vector to store some integer, it is necessary to box the int first:

Vector　v=new Vector();
int k=121;
v.addElemt(new Integer(k));

====Functionality====
Discussion of advantages and disadvantages should concerned the functionality you want to implement. For example if you want to operate a serials of int number. The performance of array may be better than int. <ref>http://cs.smith.edu/~thiebaut/ArtOfAssembly/CH05/CH05-2.html composite datatypes</ref>

[[File:1w1.gif]]

To access an element of an array, you need a function that converts an array index into the address of the indexed element. For a single dimension array, this function is very simple. It is
Element_Address = Base_Address + ((Index - Initial_Index) * Element_Size)
However, If you use five primitive data type to implement the same function. It may cost more time for the cpu to search the address of each data.

== Conclusion ==

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T02:24:43Z

Yliu63: /* Functionality */

'''Primitive objects in object-oriented languages'''

== Introduction ==

In any programming language, the [http://en.wikipedia.org/wiki/Data_type data type] refers to the class of data which contains specific type or range of values. Data types are used along with variables used in the program. The data type tells us what kind of values the variable can store, what is the range of the values and how much space the values take in memory etc.

The [http://en.wikipedia.org/wiki/Primitive_data_type primitive data types] refer to the built-in data types which are supported by the programming language. Often 'data types' and 'primitive data types' are used interchangeably. But not all data types are primitive. Programming languages have some non-primitive data types or derived data types which are provided by the language by making use of its primitive data types.

The common built-in data types or primitive data types are integers, floating point numbers, characters, strings and boolean.
* Integers - Integers represent the whole numbers which can be positive or negative or zero, e.g. 9999, 0, -25, etc.
* Floating point numbers - Floating point numbers represent the numbers which are fractions or contain floating-decimal points, e.g. -3.002, 2.5, 22.0, etc.
* Characters - Characters represent any single letter, number, space, punctuation mark, or symbol that can be typed on a computer, e.g. 'a', '9', ' ', '!' , '\n', etc.
* Strings - Strings represent the sequences of characters or simply any text, e.g. "Hello!", "9 am to 6 pm", etc.
* Booleans - Booleans represent the true or false values. Sometimes, instead of true and false, 1 and 0 are used to represent the boolean values.

Many [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming] languages provide support for primitive data types while some object-oriented programming languages provide support for primitive objects along with primitive types.

== Definition ==

Primitive objects refer to the objects of built-in classes which provide more functionality than the primitive types. Some object-oriented programming languages provide support for only primitive objects (i.e., in such languages all primitive types are objects).

Different object-oriented programming languages implement these primitive data types and primitive objects in a different manner.

== Primitive objects in different OO languages ==
=== Java ===

In [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java], there are 8 primitive types: boolean, char, byte, short, int, long, float, and double. <ref>http://www.cafeaulait.org/course/week2/02.html Java's Primitive Data Types</ref>

For each of these primitive types, Java provides [http://en.wikipedia.org/wiki/Primitive_wrapper_class wrapper classes] to create primitive objects which wrap the primitive data values. A wrapper not only contains the primitive data value, but it also defines properties and methods that can be used to manipulate that data. In Java, the primitive values are not implicitly converted to primitive objects. Instead, methods are provided for doing explicit conversion.
The primitive objects are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack heap] in memory while the variables containing primitive values are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack stack].<ref>http://www.informit.com/articles/article.aspx?p=31755&seqNum=8 Stack and Heap memory</ref>

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class!! Size
|-
| boolean || Boolean || 1-bit
|-
| char || Character || 16-bit
|-
| byte || Byte || 8-bit
|-
| short || Short || 16-bit
|-
| int || Integer || 32-bit
|-
| long || Long || 64-bit
|-
| float || Float || 32-bit
|-
| double || Double || 64-bit
|}

Example:
int i = 10;
int ii = 20;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I+II);
System.out.println(I.equals(II));

Output:
30
false

To find out if these wrapper classes are primitive or not, we can use the isPrimitive() method.

System.out.println(INTEGER.TYPE.isPrimitive());
System.out.println(BOOLEAN.TYPE.isPrimitive());

Output:
true
true

In Java, the comparison operations work in the same way on the primitive objects as well as any other class objects but different on the primitive types. The == operator when used on objects checks whether they refer to the same object but when used on variables of primitive types checks whether they contain the same value.<ref>http://leepoint.net/notes-java/data/expressions/22compareobjects.html Comparisons in Java</ref>

Example:
int i = 10;
int ii = 10;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I==II);
System.out.println(i==ii);

Output:
false
true

=== C# ===

[http://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29 C#] is a [http://en.wikipedia.org/wiki/Strong_typing strongly typed] language, where it is necessary to declare the data type of a variable and also be aware of the data type conversion. C# provides a significant number of primitive data types.<ref>http://condor.depaul.edu/sjost/ndp/notes/cs1/CSDatatypes.htm C# Primitive Datatypes</ref><ref>http://www.java2s.com/Tutorial/CSharp/0040__Data-Type/PrimitivesinC.htm Primitives in C#</ref>

Because C# represents all primitive data types as objects, it is possible to call an object method on a primitive data type. For example:

static void Main()
{
int x = 7;
object o = x;
System.Console.WriteLine(o.ToString());
}

Some data types (e.g. Decimal and String) can appear like primitives at first sight, but are actually not. So it is important to exercise caution before making such assumptions. To test whether a particular type is a primitive or not you can use the property Type.IsPrimitive.

Consider the following example:

if (t.IsPrimitive) // where t is the type
{
// Is Primitive
} else if (t == typeof(Decimal))
{
// Is Decimal
} else if (t == typeof(String))
{
// Is String
} else
{
// Other type
}

=== JavaScript ===

There are 5 primitive data types in [http://en.wikipedia.org/wiki/JavaScript JavaScript]: string, number, boolean, null and undefined. <ref>http://oreilly.com/javascript/excerpts/learning-javascript/javascript-datatypes-variables.html JavaScript Data Types and Variables</ref>

For string, number and boolean values, there are corresponding classes just like in Java to create primitive objects which wrap the primitive values.

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class
|-
| string || String
|-
| number|| Number
|-
| boolean || Boolean
|}

In JavaScript, the primitive value is implicitly converted to a primitive object whenever someone tries to access a property or invoke a method on the primitive value and the primitive object is used in place of the primitive value. Since the object contains properties and methods, the use of primitive value as an object succeeds. After the property is accessed or the method is processed, the primitive object is no longer needed and hence discarded. The same is true for the other primitive types and their corresponding primitive objects.

Example:

var upperCaseString = "APPLE";
var lowerCaseString = upperCaseString.toLowerCase(); // assigns string "apple" to lowerCaseString
var s = "Hello"
var len = s.length; // assigns value 5 to len

=== Ruby ===

Since [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is a [http://www.jvoegele.com/software/langcomp.html pure object oriented] language, everything in Ruby is an object. Hence, all primitive types such as integers, floating point numbers, strings, are objects of a built-in class.<ref>http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html Classes in Ruby</ref>
All integers are primitive objects of either class [http://corelib.rubyonrails.org/classes/Fixnum.html Fixnum] or [http://corelib.rubyonrails.org/classes/Bignum.html Bignum]. A numeric literal with a decimal point and/or an exponent is a primitive object of [http://corelib.rubyonrails.org/classes/Float.html Float]. Single quoted literals and double quoted literals are primitive objects of [http://corelib.rubyonrails.org/classes/String.html String].

Example:

puts 10.class
puts 7.45.class
puts 'hi'.class
puts "hello".class

Output:

Fixnum
Float
String
String

This indicates that 10 is converted into an object of type Fixnum, 7.45 is converted into an object of type Float, 'hi' and "hello" are both converted into an object of type String.

Since all primitive types in Ruby are objects, we should be able to call methods of the Object class on them. Let us demonstrate the same for integer and float using the following example:

a=10
puts a.to_f
b=20.5
puts b.to_i

Output:
10.0
20

== Advantages of primitives ==

Advantages that use of primitive data type offers are as follows:
===Consistency===
Many of Java’s ideas originate in C and in C++, objects and primitive type also co-exist. When object-oriented constructs were grafted onto the C language, C’s data types remained as is. The motivation behind this is that Bjarne Stroustrup, C++’s designer, wanted to be as consistent as possible with the base C language, hoping to capitalize on programmers’ pre-C++ knowledge.
<ref>http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Primitive Types Considered Harmful</ref>

===Simplicity===
It is simple and intuitive to use primitive data type in basic utility.

Example:

1. Recurring number in a loop.(C++)

for(int i=0;i<10;i++)

2. Temp variables that record only one or two data.

===Performance===

====Time====
Processing primitive data type operation would be faster than processing composite data type in most cases. There are several reasons result in this differences.
*Hardware processing discrepancy
Many primitive data operations (like integer addition) can be performed as a single machine instruction while processing of composite data type would be transformed to a combination of primitive data types. eg. Some processors offer specific instructions to process sequences of characters with a single instruction.

Example:

[http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Difference in data fetching between primitive data and composite data in Java]

*Allocating and Garbage collection overhead for composite data type<ref>http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Performance_implications Garbage collection</ref><ref>http://www.ibm.com/developerworks/java/library/j-jtp01274/index.html Java theory and practice: Garbage collection and performance</ref>
There are many initialization operations for composite data type that will generate high overheads for example boxing and unboxing, constructors and destructors.Composite data type like class will also have garbage collection overheads that may be beyond the control of the programmer and can sometimes lead to performance problems. For example, commonly used stop-the-world garbage collectors, which pause program execution at arbitrary times, may make garbage collection inappropriate for some [http://en.wikipedia.org/wiki/Embedded_system embedded systems], high-performance [http://en.wikipedia.org/wiki/Server_(computing) server] software, and applications with [http://en.wikipedia.org/wiki/Real-time_computing real-time] needs.In the early days of Java technology, allocating objects got a high overheads. There were lots of articles advising developers to avoid creating temporary objects unnecessarily because allocation (and the corresponding garbage-collection overhead) was expensive. Although the costs have been greatly reduced nowadays. It still much slower than primitive data type which don’t have such troubles.

Example:

public class Test{
double dur1,dur2;
int N=100000000;
public void test1()
{
int a=1,b=1;
long startTime1 = System.currentTimeMillis();
for(int i=0;i<N;i++){
a=a+b;
}
long endTime1 = System.currentTimeMillis();
System.out.println(endTime1-startTime1);
}
public void test2(){
Integer c=new Integer(1);
Integer d=new Integer(1);
long startTime2 = System.currentTimeMillis();
for(int i=0;i<N;i++){
c=c+d;
}
long endTime2 = System.currentTimeMillis();
System.out.println(endTime2-startTime2)
}

Average execution time for test1 is: 1 mm

Average execution time for test2 is: 702mm

(test case number: 1000 times )

====Space====
Composite data type will cost more memory space than primitive data type in general. The reason is not only for the overheads generated by constructors, destructors etc, but also the feature of data alignment. <ref>http://en.wikipedia.org/wiki/Data_structure_alignment#Data_structure_padding Data structure alignment</ref>

Example of data alignment （C++）
struct compose
{
char name;
int a;
int b;
}

We all know the size of char is 1 byte, the size of int is 4 bytes. But the size of the struct compose as shown above is 12 bytes but not 9 bytes.

== Disdvantages of primitives ==

The various disadvantages of using the primitive data types are as follows:

===Cannot be extended===
We can use class or array to express the intricate data or functional structure. And programmers can create subtypes, modify their operations and even redefine them. In addition with the feature of class, programmers can make their variables unchangeable to any code outside the class, or make the implementation hidden to other code with call the methods. That means with composite data types, it will be more convenient for the programmers to handle sophisticated data and also make the code easier to maintain.

We can create a Person type in RUBY. We defined a “talk” method to make a Person can talk about himself. We also hope to only make the variable “motherland” changeable by the code outside this class.

Example：

class Person

def initialize( name, age=18 )
@name = name
@age = age
@motherland = "US"
end

def talk
puts "my name is "+@name+", age is "+@age.to_s
if @motherland == "US"
puts "I\'m American."
else
puts "I\'m International."
end
end
attr_writer :motherland
end

Later when we need to create a “Student” type, we can just inherent the “Person” type and make some adjustment based on our needs. Here we redefine the “talk” method to make a student talk in a different way.

class Student < Person

def talk
puts "I am a student. my name is "+@name+", age is "+@age.to_s
end
end

===Uncertainty===
Though it means more processing time, it is necessary for programmers to create composite type to handle the data whose length is too large or changing all the time. If we have a set or integers to maintain in memory, but the number of integers will change every minute, it will be impossible if we only use primitive types to handle. But we can make use of the “Arraylist” type in Java or other composite types. With the “Arraylist”, the programmers do not need to pay attention to the storage in the memory or the space it takes. The compiler of Java will reallocate more space automatically for the Arraylist if more elements are putted. <ref>http://docs.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html uncertainty of array</ref>

Here is an example for the insert and sorting methods of the Arraylist type in Java:

ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.Sort();

===Limitation===

For the primitive data types in most programming languages, there are some limits of the length. For example we can put an integer between -(2^16) and (2^16)-1 into an “int” in Java. That will be enough for some most of the cases but definitely not all of them. For example, the primitive types are not able for a scientific calculation if we need an accuracy on 10^-500. And a more extreme case is to calculate the last 100 numbers for the PI has a 100 million length.<ref>http://en.verysource.com/code/1285797_1/tlargefloat.h.html limitation of primitive</ref>

For these situations, the programmers usually need to create a composite data type by themselves. They can even redefine the operators (“+”, “-”) to make the super-long float also can make addition, subtraction with ordinary operators instead of method calling. For more details to create a super long float please see reference.

===Cannot simplify the utility function associated with non primitive data types===

Most of the object oriented languages have certain utility functions associated with non primitive data types that ease their use as compared to primitive data types that do not have such functions. An especially useful example is the method of parsing integers in a specified radix in Java (Integer.parseInt). <ref>http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html utility function associated with non primitive data types</ref>

parseInt("1100110", 2); //returns 102
parseInt("-0", 10); //returns 0
parseInt("-FF", 16); //returns -255
parseInt("99", 8); //throws a NumberFormatException

From the above examples, it is obvious that “Integer” type not just support ordinary methods an integer should have (such as Integer.equals), but also some more utility methods which are helpful for the programmers.

In addition, for some data structure which only take object but not primitive type (such as Vector in Java), it is necessary to box a primitive data type to a corresponding object. For example if a programmer needs to make use of a vector to store some integer, it is necessary to box the int first:

Vector　v=new Vector();
int k=121;
v.addElemt(new Integer(k));

== Conclusion ==

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T02:21:39Z

Yliu63: /* Time */

'''Primitive objects in object-oriented languages'''

== Introduction ==

In any programming language, the [http://en.wikipedia.org/wiki/Data_type data type] refers to the class of data which contains specific type or range of values. Data types are used along with variables used in the program. The data type tells us what kind of values the variable can store, what is the range of the values and how much space the values take in memory etc.

The [http://en.wikipedia.org/wiki/Primitive_data_type primitive data types] refer to the built-in data types which are supported by the programming language. Often 'data types' and 'primitive data types' are used interchangeably. But not all data types are primitive. Programming languages have some non-primitive data types or derived data types which are provided by the language by making use of its primitive data types.

The common built-in data types or primitive data types are integers, floating point numbers, characters, strings and boolean.
* Integers - Integers represent the whole numbers which can be positive or negative or zero, e.g. 9999, 0, -25, etc.
* Floating point numbers - Floating point numbers represent the numbers which are fractions or contain floating-decimal points, e.g. -3.002, 2.5, 22.0, etc.
* Characters - Characters represent any single letter, number, space, punctuation mark, or symbol that can be typed on a computer, e.g. 'a', '9', ' ', '!' , '\n', etc.
* Strings - Strings represent the sequences of characters or simply any text, e.g. "Hello!", "9 am to 6 pm", etc.
* Booleans - Booleans represent the true or false values. Sometimes, instead of true and false, 1 and 0 are used to represent the boolean values.

Many [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming] languages provide support for primitive data types while some object-oriented programming languages provide support for primitive objects along with primitive types.

== Definition ==

Primitive objects refer to the objects of built-in classes which provide more functionality than the primitive types. Some object-oriented programming languages provide support for only primitive objects (i.e., in such languages all primitive types are objects).

Different object-oriented programming languages implement these primitive data types and primitive objects in a different manner.

== Primitive objects in different OO languages ==
=== Java ===

In [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java], there are 8 primitive types: boolean, char, byte, short, int, long, float, and double. <ref>http://www.cafeaulait.org/course/week2/02.html Java's Primitive Data Types</ref>

For each of these primitive types, Java provides [http://en.wikipedia.org/wiki/Primitive_wrapper_class wrapper classes] to create primitive objects which wrap the primitive data values. A wrapper not only contains the primitive data value, but it also defines properties and methods that can be used to manipulate that data. In Java, the primitive values are not implicitly converted to primitive objects. Instead, methods are provided for doing explicit conversion.
The primitive objects are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack heap] in memory while the variables containing primitive values are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack stack].<ref>http://www.informit.com/articles/article.aspx?p=31755&seqNum=8 Stack and Heap memory</ref>

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class!! Size
|-
| boolean || Boolean || 1-bit
|-
| char || Character || 16-bit
|-
| byte || Byte || 8-bit
|-
| short || Short || 16-bit
|-
| int || Integer || 32-bit
|-
| long || Long || 64-bit
|-
| float || Float || 32-bit
|-
| double || Double || 64-bit
|}

Example:
int i = 10;
int ii = 20;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I+II);
System.out.println(I.equals(II));

Output:
30
false

To find out if these wrapper classes are primitive or not, we can use the isPrimitive() method.

System.out.println(INTEGER.TYPE.isPrimitive());
System.out.println(BOOLEAN.TYPE.isPrimitive());

Output:
true
true

In Java, the comparison operations work in the same way on the primitive objects as well as any other class objects but different on the primitive types. The == operator when used on objects checks whether they refer to the same object but when used on variables of primitive types checks whether they contain the same value.<ref>http://leepoint.net/notes-java/data/expressions/22compareobjects.html Comparisons in Java</ref>

Example:
int i = 10;
int ii = 10;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I==II);
System.out.println(i==ii);

Output:
false
true

=== C# ===

[http://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29 C#] is a [http://en.wikipedia.org/wiki/Strong_typing strongly typed] language, where it is necessary to declare the data type of a variable and also be aware of the data type conversion. C# provides a significant number of primitive data types.<ref>http://condor.depaul.edu/sjost/ndp/notes/cs1/CSDatatypes.htm C# Primitive Datatypes</ref><ref>http://www.java2s.com/Tutorial/CSharp/0040__Data-Type/PrimitivesinC.htm Primitives in C#</ref>

Because C# represents all primitive data types as objects, it is possible to call an object method on a primitive data type. For example:

static void Main()
{
int x = 7;
object o = x;
System.Console.WriteLine(o.ToString());
}

Some data types (e.g. Decimal and String) can appear like primitives at first sight, but are actually not. So it is important to exercise caution before making such assumptions. To test whether a particular type is a primitive or not you can use the property Type.IsPrimitive.

Consider the following example:

if (t.IsPrimitive) // where t is the type
{
// Is Primitive
} else if (t == typeof(Decimal))
{
// Is Decimal
} else if (t == typeof(String))
{
// Is String
} else
{
// Other type
}

=== JavaScript ===

There are 5 primitive data types in [http://en.wikipedia.org/wiki/JavaScript JavaScript]: string, number, boolean, null and undefined. <ref>http://oreilly.com/javascript/excerpts/learning-javascript/javascript-datatypes-variables.html JavaScript Data Types and Variables</ref>

For string, number and boolean values, there are corresponding classes just like in Java to create primitive objects which wrap the primitive values.

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class
|-
| string || String
|-
| number|| Number
|-
| boolean || Boolean
|}

In JavaScript, the primitive value is implicitly converted to a primitive object whenever someone tries to access a property or invoke a method on the primitive value and the primitive object is used in place of the primitive value. Since the object contains properties and methods, the use of primitive value as an object succeeds. After the property is accessed or the method is processed, the primitive object is no longer needed and hence discarded. The same is true for the other primitive types and their corresponding primitive objects.

Example:

var upperCaseString = "APPLE";
var lowerCaseString = upperCaseString.toLowerCase(); // assigns string "apple" to lowerCaseString
var s = "Hello"
var len = s.length; // assigns value 5 to len

=== Ruby ===

Since [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is a [http://www.jvoegele.com/software/langcomp.html pure object oriented] language, everything in Ruby is an object. Hence, all primitive types such as integers, floating point numbers, strings, are objects of a built-in class.<ref>http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html Classes in Ruby</ref>
All integers are primitive objects of either class [http://corelib.rubyonrails.org/classes/Fixnum.html Fixnum] or [http://corelib.rubyonrails.org/classes/Bignum.html Bignum]. A numeric literal with a decimal point and/or an exponent is a primitive object of [http://corelib.rubyonrails.org/classes/Float.html Float]. Single quoted literals and double quoted literals are primitive objects of [http://corelib.rubyonrails.org/classes/String.html String].

Example:

puts 10.class
puts 7.45.class
puts 'hi'.class
puts "hello".class

Output:

Fixnum
Float
String
String

This indicates that 10 is converted into an object of type Fixnum, 7.45 is converted into an object of type Float, 'hi' and "hello" are both converted into an object of type String.

Since all primitive types in Ruby are objects, we should be able to call methods of the Object class on them. Let us demonstrate the same for integer and float using the following example:

a=10
puts a.to_f
b=20.5
puts b.to_i

Output:
10.0
20

== Advantages of primitives ==

Advantages that use of primitive data type offers are as follows:
===Consistency===
Many of Java’s ideas originate in C and in C++, objects and primitive type also co-exist. When object-oriented constructs were grafted onto the C language, C’s data types remained as is. The motivation behind this is that Bjarne Stroustrup, C++’s designer, wanted to be as consistent as possible with the base C language, hoping to capitalize on programmers’ pre-C++ knowledge.
<ref>http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Primitive Types Considered Harmful</ref>

===Simplicity===
It is simple and intuitive to use primitive data type in basic utility.

Example:

1. Recurring number in a loop.(C++)

for(int i=0;i<10;i++)

2. Temp variables that record only one or two data.

===Performance===

====Time====
Processing primitive data type operation would be faster than processing composite data type in most cases. There are several reasons result in this differences.
*Hardware processing discrepancy
Many primitive data operations (like integer addition) can be performed as a single machine instruction while processing of composite data type would be transformed to a combination of primitive data types. eg. Some processors offer specific instructions to process sequences of characters with a single instruction.

Example:

[http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Difference in data fetching between primitive data and composite data in Java]

*Allocating and Garbage collection overhead for composite data type<ref>http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Performance_implications Garbage collection</ref><ref>http://www.ibm.com/developerworks/java/library/j-jtp01274/index.html Java theory and practice: Garbage collection and performance</ref>
There are many initialization operations for composite data type that will generate high overheads for example boxing and unboxing, constructors and destructors.Composite data type like class will also have garbage collection overheads that may be beyond the control of the programmer and can sometimes lead to performance problems. For example, commonly used stop-the-world garbage collectors, which pause program execution at arbitrary times, may make garbage collection inappropriate for some [http://en.wikipedia.org/wiki/Embedded_system embedded systems], high-performance [http://en.wikipedia.org/wiki/Server_(computing) server] software, and applications with [http://en.wikipedia.org/wiki/Real-time_computing real-time] needs.In the early days of Java technology, allocating objects got a high overheads. There were lots of articles advising developers to avoid creating temporary objects unnecessarily because allocation (and the corresponding garbage-collection overhead) was expensive. Although the costs have been greatly reduced nowadays. It still much slower than primitive data type which don’t have such troubles.

Example:

public class Test{
double dur1,dur2;
int N=100000000;
public void test1()
{
int a=1,b=1;
long startTime1 = System.currentTimeMillis();
for(int i=0;i<N;i++){
a=a+b;
}
long endTime1 = System.currentTimeMillis();
System.out.println(endTime1-startTime1);
}
public void test2(){
Integer c=new Integer(1);
Integer d=new Integer(1);
long startTime2 = System.currentTimeMillis();
for(int i=0;i<N;i++){
c=c+d;
}
long endTime2 = System.currentTimeMillis();
System.out.println(endTime2-startTime2)
}

Average execution time for test1 is: 1 mm

Average execution time for test2 is: 702mm

(test case number: 1000 times )

====Space====
Composite data type will cost more memory space than primitive data type in general. The reason is not only for the overheads generated by constructors, destructors etc, but also the feature of data alignment. <ref>http://en.wikipedia.org/wiki/Data_structure_alignment#Data_structure_padding Data structure alignment</ref>

Example of data alignment （C++）
struct compose
{
char name;
int a;
int b;
}

We all know the size of char is 1 byte, the size of int is 4 bytes. But the size of the struct compose as shown above is 12 bytes but not 9 bytes.

====Functionality====
Discussion of advantages and disadvantages should concerned the functionality you want to implement. For example if you want to operate a serials of int number. The performance of array may be better than int. <ref>http://cs.smith.edu/~thiebaut/ArtOfAssembly/CH05/CH05-2.html composite datatypes</ref>

[[File:1w1.gif]]

To access an element of an array, you need a function that converts an array index into the address of the indexed element. For a single dimension array, this function is very simple. It is
Element_Address = Base_Address + ((Index - Initial_Index) * Element_Size)
However, If you use five primitive data type to implement the same function. It may cost more time for the cpu to search the address of each data.

== Disdvantages of primitives ==

The various disadvantages of using the primitive data types are as follows:

===Cannot be extended===
We can use class or array to express the intricate data or functional structure. And programmers can create subtypes, modify their operations and even redefine them. In addition with the feature of class, programmers can make their variables unchangeable to any code outside the class, or make the implementation hidden to other code with call the methods. That means with composite data types, it will be more convenient for the programmers to handle sophisticated data and also make the code easier to maintain.

We can create a Person type in RUBY. We defined a “talk” method to make a Person can talk about himself. We also hope to only make the variable “motherland” changeable by the code outside this class.

Example：

class Person

def initialize( name, age=18 )
@name = name
@age = age
@motherland = "US"
end

def talk
puts "my name is "+@name+", age is "+@age.to_s
if @motherland == "US"
puts "I\'m American."
else
puts "I\'m International."
end
end
attr_writer :motherland
end

Later when we need to create a “Student” type, we can just inherent the “Person” type and make some adjustment based on our needs. Here we redefine the “talk” method to make a student talk in a different way.

class Student < Person

def talk
puts "I am a student. my name is "+@name+", age is "+@age.to_s
end
end

===Uncertainty===
Though it means more processing time, it is necessary for programmers to create composite type to handle the data whose length is too large or changing all the time. If we have a set or integers to maintain in memory, but the number of integers will change every minute, it will be impossible if we only use primitive types to handle. But we can make use of the “Arraylist” type in Java or other composite types. With the “Arraylist”, the programmers do not need to pay attention to the storage in the memory or the space it takes. The compiler of Java will reallocate more space automatically for the Arraylist if more elements are putted. <ref>http://docs.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html uncertainty of array</ref>

Here is an example for the insert and sorting methods of the Arraylist type in Java:

ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.Sort();

===Limitation===

For the primitive data types in most programming languages, there are some limits of the length. For example we can put an integer between -(2^16) and (2^16)-1 into an “int” in Java. That will be enough for some most of the cases but definitely not all of them. For example, the primitive types are not able for a scientific calculation if we need an accuracy on 10^-500. And a more extreme case is to calculate the last 100 numbers for the PI has a 100 million length.<ref>http://en.verysource.com/code/1285797_1/tlargefloat.h.html limitation of primitive</ref>

For these situations, the programmers usually need to create a composite data type by themselves. They can even redefine the operators (“+”, “-”) to make the super-long float also can make addition, subtraction with ordinary operators instead of method calling. For more details to create a super long float please see reference.

===Cannot simplify the utility function associated with non primitive data types===

Most of the object oriented languages have certain utility functions associated with non primitive data types that ease their use as compared to primitive data types that do not have such functions. An especially useful example is the method of parsing integers in a specified radix in Java (Integer.parseInt). <ref>http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html utility function associated with non primitive data types</ref>

parseInt("1100110", 2); //returns 102
parseInt("-0", 10); //returns 0
parseInt("-FF", 16); //returns -255
parseInt("99", 8); //throws a NumberFormatException

From the above examples, it is obvious that “Integer” type not just support ordinary methods an integer should have (such as Integer.equals), but also some more utility methods which are helpful for the programmers.

In addition, for some data structure which only take object but not primitive type (such as Vector in Java), it is necessary to box a primitive data type to a corresponding object. For example if a programmer needs to make use of a vector to store some integer, it is necessary to box the int first:

Vector　v=new Vector();
int k=121;
v.addElemt(new Integer(k));

== Conclusion ==

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T02:18:01Z

Yliu63: /* cannot simplify the utility function associated with non primitive data types */

'''Primitive objects in object-oriented languages'''

== Introduction ==

In any programming language, the [http://en.wikipedia.org/wiki/Data_type data type] refers to the class of data which contains specific type or range of values. Data types are used along with variables used in the program. The data type tells us what kind of values the variable can store, what is the range of the values and how much space the values take in memory etc.

The [http://en.wikipedia.org/wiki/Primitive_data_type primitive data types] refer to the built-in data types which are supported by the programming language. Often 'data types' and 'primitive data types' are used interchangeably. But not all data types are primitive. Programming languages have some non-primitive data types or derived data types which are provided by the language by making use of its primitive data types.

The common built-in data types or primitive data types are integers, floating point numbers, characters, strings and boolean.
* Integers - Integers represent the whole numbers which can be positive or negative or zero, e.g. 9999, 0, -25, etc.
* Floating point numbers - Floating point numbers represent the numbers which are fractions or contain floating-decimal points, e.g. -3.002, 2.5, 22.0, etc.
* Characters - Characters represent any single letter, number, space, punctuation mark, or symbol that can be typed on a computer, e.g. 'a', '9', ' ', '!' , '\n', etc.
* Strings - Strings represent the sequences of characters or simply any text, e.g. "Hello!", "9 am to 6 pm", etc.
* Booleans - Booleans represent the true or false values. Sometimes, instead of true and false, 1 and 0 are used to represent the boolean values.

Many [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming] languages provide support for primitive data types while some object-oriented programming languages provide support for primitive objects along with primitive types.

== Definition ==

Primitive objects refer to the objects of built-in classes which provide more functionality than the primitive types. Some object-oriented programming languages provide support for only primitive objects (i.e., in such languages all primitive types are objects).

Different object-oriented programming languages implement these primitive data types and primitive objects in a different manner.

== Primitive objects in different OO languages ==
=== Java ===

In [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java], there are 8 primitive types: boolean, char, byte, short, int, long, float, and double. <ref>http://www.cafeaulait.org/course/week2/02.html Java's Primitive Data Types</ref>

For each of these primitive types, Java provides [http://en.wikipedia.org/wiki/Primitive_wrapper_class wrapper classes] to create primitive objects which wrap the primitive data values. A wrapper not only contains the primitive data value, but it also defines properties and methods that can be used to manipulate that data. In Java, the primitive values are not implicitly converted to primitive objects. Instead, methods are provided for doing explicit conversion.
The primitive objects are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack heap] in memory while the variables containing primitive values are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack stack].<ref>http://www.informit.com/articles/article.aspx?p=31755&seqNum=8 Stack and Heap memory</ref>

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class!! Size
|-
| boolean || Boolean || 1-bit
|-
| char || Character || 16-bit
|-
| byte || Byte || 8-bit
|-
| short || Short || 16-bit
|-
| int || Integer || 32-bit
|-
| long || Long || 64-bit
|-
| float || Float || 32-bit
|-
| double || Double || 64-bit
|}

Example:
int i = 10;
int ii = 20;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I+II);
System.out.println(I.equals(II));

Output:
30
false

To find out if these wrapper classes are primitive or not, we can use the isPrimitive() method.

System.out.println(INTEGER.TYPE.isPrimitive());
System.out.println(BOOLEAN.TYPE.isPrimitive());

Output:
true
true

In Java, the comparison operations work in the same way on the primitive objects as well as any other class objects but different on the primitive types. The == operator when used on objects checks whether they refer to the same object but when used on variables of primitive types checks whether they contain the same value.<ref>http://leepoint.net/notes-java/data/expressions/22compareobjects.html Comparisons in Java</ref>

Example:
int i = 10;
int ii = 10;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I==II);
System.out.println(i==ii);

Output:
false
true

=== C# ===

[http://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29 C#] is a [http://en.wikipedia.org/wiki/Strong_typing strongly typed] language, where it is necessary to declare the data type of a variable and also be aware of the data type conversion. C# provides a significant number of primitive data types.<ref>http://condor.depaul.edu/sjost/ndp/notes/cs1/CSDatatypes.htm C# Primitive Datatypes</ref><ref>http://www.java2s.com/Tutorial/CSharp/0040__Data-Type/PrimitivesinC.htm Primitives in C#</ref>

Because C# represents all primitive data types as objects, it is possible to call an object method on a primitive data type. For example:

static void Main()
{
int x = 7;
object o = x;
System.Console.WriteLine(o.ToString());
}

Some data types (e.g. Decimal and String) can appear like primitives at first sight, but are actually not. So it is important to exercise caution before making such assumptions. To test whether a particular type is a primitive or not you can use the property Type.IsPrimitive.

Consider the following example:

if (t.IsPrimitive) // where t is the type
{
// Is Primitive
} else if (t == typeof(Decimal))
{
// Is Decimal
} else if (t == typeof(String))
{
// Is String
} else
{
// Other type
}

=== JavaScript ===

There are 5 primitive data types in [http://en.wikipedia.org/wiki/JavaScript JavaScript]: string, number, boolean, null and undefined. <ref>http://oreilly.com/javascript/excerpts/learning-javascript/javascript-datatypes-variables.html JavaScript Data Types and Variables</ref>

For string, number and boolean values, there are corresponding classes just like in Java to create primitive objects which wrap the primitive values.

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class
|-
| string || String
|-
| number|| Number
|-
| boolean || Boolean
|}

In JavaScript, the primitive value is implicitly converted to a primitive object whenever someone tries to access a property or invoke a method on the primitive value and the primitive object is used in place of the primitive value. Since the object contains properties and methods, the use of primitive value as an object succeeds. After the property is accessed or the method is processed, the primitive object is no longer needed and hence discarded. The same is true for the other primitive types and their corresponding primitive objects.

Example:

var upperCaseString = "APPLE";
var lowerCaseString = upperCaseString.toLowerCase(); // assigns string "apple" to lowerCaseString
var s = "Hello"
var len = s.length; // assigns value 5 to len

=== Ruby ===

Since [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is a [http://www.jvoegele.com/software/langcomp.html pure object oriented] language, everything in Ruby is an object. Hence, all primitive types such as integers, floating point numbers, strings, are objects of a built-in class.<ref>http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html Classes in Ruby</ref>
All integers are primitive objects of either class [http://corelib.rubyonrails.org/classes/Fixnum.html Fixnum] or [http://corelib.rubyonrails.org/classes/Bignum.html Bignum]. A numeric literal with a decimal point and/or an exponent is a primitive object of [http://corelib.rubyonrails.org/classes/Float.html Float]. Single quoted literals and double quoted literals are primitive objects of [http://corelib.rubyonrails.org/classes/String.html String].

Example:

puts 10.class
puts 7.45.class
puts 'hi'.class
puts "hello".class

Output:

Fixnum
Float
String
String

This indicates that 10 is converted into an object of type Fixnum, 7.45 is converted into an object of type Float, 'hi' and "hello" are both converted into an object of type String.

Since all primitive types in Ruby are objects, we should be able to call methods of the Object class on them. Let us demonstrate the same for integer and float using the following example:

a=10
puts a.to_f
b=20.5
puts b.to_i

Output:
10.0
20

== Advantages of primitives ==

Advantages that use of primitive data type offers are as follows:
===Consistency===
Many of Java’s ideas originate in C and in C++, objects and primitive type also co-exist. When object-oriented constructs were grafted onto the C language, C’s data types remained as is. The motivation behind this is that Bjarne Stroustrup, C++’s designer, wanted to be as consistent as possible with the base C language, hoping to capitalize on programmers’ pre-C++ knowledge.
<ref>http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Primitive Types Considered Harmful</ref>

===Simplicity===
It is simple and intuitive to use primitive data type in basic utility.

Example:

1. Recurring number in a loop.(C++)

for(int i=0;i<10;i++)

2. Temp variables that record only one or two data.

===Performance===

====Time====
Processing primitive data type operation would be faster than processing composite data type in most cases. There are several reasons result in this differences.
*Hardware processing discrepancy
Many primitive data operations (like integer addition) can be performed as a single machine instruction while processing of composite data type would be transformed to a combination of primitive data types. eg. Some processors offer specific instructions to process sequences of characters with a single instruction.

Example:

[http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Difference in data fetching between primitive data and composite data in Java]

*Allocating and Garbage collection overhead for composite data type<ref>http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Performance_implications Garbage collection</ref><ref>http://www.ibm.com/developerworks/java/library/j-jtp01274/index.html Java theory and practice: Garbage collection and performance</ref>
There are many initialization operations for composite data type that will generate high overheads for example boxing and unboxing, constructors and destructors.Composite data type like class will also have garbage collection overheads that may be beyond the control of the programmer and can sometimes lead to performance problems. For example, commonly used stop-the-world garbage collectors, which pause program execution at arbitrary times, may make garbage collection inappropriate for some [http://en.wikipedia.org/wiki/Embedded_system embedded systems], high-performance [http://en.wikipedia.org/wiki/Server_(computing) server] software, and applications with [http://en.wikipedia.org/wiki/Real-time_computing real-time] needs.In the early days of Java technology, allocating objects got a high overheads. There were lots of articles advising developers to avoid creating temporary objects unnecessarily because allocation (and the corresponding garbage-collection overhead) was expensive. Although the costs have been greatly reduced nowadays. It still much slower than primitive data type which don’t have such troubles.

Example:

public class Test{
double dur1,dur2;
int N=100000000;
public void test1()
{
int a=1,b=1;
long startTime1 = System.currentTimeMillis();
for(int i=0;i<N;i++){
a=a+b;
}
long endTime1 = System.currentTimeMillis();
System.out.println(endTime1-startTime1);
}
public void test2(){
Integer c=new Integer(1);
Integer d=new Integer(1);
long startTime2 = System.currentTimeMillis();
for(int i=0;i<N;i++){
c=c+d;
}
long endTime2 = System.currentTimeMillis();
System.out.println(endTime2-startTime2)
}

'''Average execution time for test1 is: 1 mm'''

'''Average execution time for test2 is: 702mm'''

'''(test case number: 1000 times )'''

====Space====
Composite data type will cost more memory space than primitive data type in general. The reason is not only for the overheads generated by constructors, destructors etc, but also the feature of data alignment. <ref>http://en.wikipedia.org/wiki/Data_structure_alignment#Data_structure_padding Data structure alignment</ref>

Example of data alignment （C++）
struct compose
{
char name;
int a;
int b;
}

We all know the size of char is 1 byte, the size of int is 4 bytes. But the size of the struct compose as shown above is 12 bytes but not 9 bytes.

====Functionality====
Discussion of advantages and disadvantages should concerned the functionality you want to implement. For example if you want to operate a serials of int number. The performance of array may be better than int. <ref>http://cs.smith.edu/~thiebaut/ArtOfAssembly/CH05/CH05-2.html composite datatypes</ref>

[[File:1w1.gif]]

To access an element of an array, you need a function that converts an array index into the address of the indexed element. For a single dimension array, this function is very simple. It is
Element_Address = Base_Address + ((Index - Initial_Index) * Element_Size)
However, If you use five primitive data type to implement the same function. It may cost more time for the cpu to search the address of each data.

== Disdvantages of primitives ==

The various disadvantages of using the primitive data types are as follows:

===Cannot be extended===
We can use class or array to express the intricate data or functional structure. And programmers can create subtypes, modify their operations and even redefine them. In addition with the feature of class, programmers can make their variables unchangeable to any code outside the class, or make the implementation hidden to other code with call the methods. That means with composite data types, it will be more convenient for the programmers to handle sophisticated data and also make the code easier to maintain.

We can create a Person type in RUBY. We defined a “talk” method to make a Person can talk about himself. We also hope to only make the variable “motherland” changeable by the code outside this class.

Example：

class Person

def initialize( name, age=18 )
@name = name
@age = age
@motherland = "US"
end

def talk
puts "my name is "+@name+", age is "+@age.to_s
if @motherland == "US"
puts "I\'m American."
else
puts "I\'m International."
end
end
attr_writer :motherland
end

Later when we need to create a “Student” type, we can just inherent the “Person” type and make some adjustment based on our needs. Here we redefine the “talk” method to make a student talk in a different way.

class Student < Person

def talk
puts "I am a student. my name is "+@name+", age is "+@age.to_s
end
end

===Uncertainty===
Though it means more processing time, it is necessary for programmers to create composite type to handle the data whose length is too large or changing all the time. If we have a set or integers to maintain in memory, but the number of integers will change every minute, it will be impossible if we only use primitive types to handle. But we can make use of the “Arraylist” type in Java or other composite types. With the “Arraylist”, the programmers do not need to pay attention to the storage in the memory or the space it takes. The compiler of Java will reallocate more space automatically for the Arraylist if more elements are putted. <ref>http://docs.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html uncertainty of array</ref>

Here is an example for the insert and sorting methods of the Arraylist type in Java:

ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.Sort();

===Limitation===

For the primitive data types in most programming languages, there are some limits of the length. For example we can put an integer between -(2^16) and (2^16)-1 into an “int” in Java. That will be enough for some most of the cases but definitely not all of them. For example, the primitive types are not able for a scientific calculation if we need an accuracy on 10^-500. And a more extreme case is to calculate the last 100 numbers for the PI has a 100 million length.<ref>http://en.verysource.com/code/1285797_1/tlargefloat.h.html limitation of primitive</ref>

For these situations, the programmers usually need to create a composite data type by themselves. They can even redefine the operators (“+”, “-”) to make the super-long float also can make addition, subtraction with ordinary operators instead of method calling. For more details to create a super long float please see reference.

===Cannot simplify the utility function associated with non primitive data types===

Most of the object oriented languages have certain utility functions associated with non primitive data types that ease their use as compared to primitive data types that do not have such functions. An especially useful example is the method of parsing integers in a specified radix in Java (Integer.parseInt). <ref>http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html utility function associated with non primitive data types</ref>

parseInt("1100110", 2); //returns 102
parseInt("-0", 10); //returns 0
parseInt("-FF", 16); //returns -255
parseInt("99", 8); //throws a NumberFormatException

From the above examples, it is obvious that “Integer” type not just support ordinary methods an integer should have (such as Integer.equals), but also some more utility methods which are helpful for the programmers.

In addition, for some data structure which only take object but not primitive type (such as Vector in Java), it is necessary to box a primitive data type to a corresponding object. For example if a programmer needs to make use of a vector to store some integer, it is necessary to box the int first:

Vector　v=new Vector();
int k=121;
v.addElemt(new Integer(k));

== Conclusion ==

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T02:17:52Z

Yliu63: /* limitation */

'''Primitive objects in object-oriented languages'''

== Introduction ==

In any programming language, the [http://en.wikipedia.org/wiki/Data_type data type] refers to the class of data which contains specific type or range of values. Data types are used along with variables used in the program. The data type tells us what kind of values the variable can store, what is the range of the values and how much space the values take in memory etc.

The [http://en.wikipedia.org/wiki/Primitive_data_type primitive data types] refer to the built-in data types which are supported by the programming language. Often 'data types' and 'primitive data types' are used interchangeably. But not all data types are primitive. Programming languages have some non-primitive data types or derived data types which are provided by the language by making use of its primitive data types.

The common built-in data types or primitive data types are integers, floating point numbers, characters, strings and boolean.
* Integers - Integers represent the whole numbers which can be positive or negative or zero, e.g. 9999, 0, -25, etc.
* Floating point numbers - Floating point numbers represent the numbers which are fractions or contain floating-decimal points, e.g. -3.002, 2.5, 22.0, etc.
* Characters - Characters represent any single letter, number, space, punctuation mark, or symbol that can be typed on a computer, e.g. 'a', '9', ' ', '!' , '\n', etc.
* Strings - Strings represent the sequences of characters or simply any text, e.g. "Hello!", "9 am to 6 pm", etc.
* Booleans - Booleans represent the true or false values. Sometimes, instead of true and false, 1 and 0 are used to represent the boolean values.

Many [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming] languages provide support for primitive data types while some object-oriented programming languages provide support for primitive objects along with primitive types.

== Definition ==

Primitive objects refer to the objects of built-in classes which provide more functionality than the primitive types. Some object-oriented programming languages provide support for only primitive objects (i.e., in such languages all primitive types are objects).

Different object-oriented programming languages implement these primitive data types and primitive objects in a different manner.

== Primitive objects in different OO languages ==
=== Java ===

In [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java], there are 8 primitive types: boolean, char, byte, short, int, long, float, and double. <ref>http://www.cafeaulait.org/course/week2/02.html Java's Primitive Data Types</ref>

For each of these primitive types, Java provides [http://en.wikipedia.org/wiki/Primitive_wrapper_class wrapper classes] to create primitive objects which wrap the primitive data values. A wrapper not only contains the primitive data value, but it also defines properties and methods that can be used to manipulate that data. In Java, the primitive values are not implicitly converted to primitive objects. Instead, methods are provided for doing explicit conversion.
The primitive objects are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack heap] in memory while the variables containing primitive values are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack stack].<ref>http://www.informit.com/articles/article.aspx?p=31755&seqNum=8 Stack and Heap memory</ref>

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class!! Size
|-
| boolean || Boolean || 1-bit
|-
| char || Character || 16-bit
|-
| byte || Byte || 8-bit
|-
| short || Short || 16-bit
|-
| int || Integer || 32-bit
|-
| long || Long || 64-bit
|-
| float || Float || 32-bit
|-
| double || Double || 64-bit
|}

Example:
int i = 10;
int ii = 20;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I+II);
System.out.println(I.equals(II));

Output:
30
false

To find out if these wrapper classes are primitive or not, we can use the isPrimitive() method.

System.out.println(INTEGER.TYPE.isPrimitive());
System.out.println(BOOLEAN.TYPE.isPrimitive());

Output:
true
true

In Java, the comparison operations work in the same way on the primitive objects as well as any other class objects but different on the primitive types. The == operator when used on objects checks whether they refer to the same object but when used on variables of primitive types checks whether they contain the same value.<ref>http://leepoint.net/notes-java/data/expressions/22compareobjects.html Comparisons in Java</ref>

Example:
int i = 10;
int ii = 10;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I==II);
System.out.println(i==ii);

Output:
false
true

=== C# ===

[http://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29 C#] is a [http://en.wikipedia.org/wiki/Strong_typing strongly typed] language, where it is necessary to declare the data type of a variable and also be aware of the data type conversion. C# provides a significant number of primitive data types.<ref>http://condor.depaul.edu/sjost/ndp/notes/cs1/CSDatatypes.htm C# Primitive Datatypes</ref><ref>http://www.java2s.com/Tutorial/CSharp/0040__Data-Type/PrimitivesinC.htm Primitives in C#</ref>

Because C# represents all primitive data types as objects, it is possible to call an object method on a primitive data type. For example:

static void Main()
{
int x = 7;
object o = x;
System.Console.WriteLine(o.ToString());
}

Some data types (e.g. Decimal and String) can appear like primitives at first sight, but are actually not. So it is important to exercise caution before making such assumptions. To test whether a particular type is a primitive or not you can use the property Type.IsPrimitive.

Consider the following example:

if (t.IsPrimitive) // where t is the type
{
// Is Primitive
} else if (t == typeof(Decimal))
{
// Is Decimal
} else if (t == typeof(String))
{
// Is String
} else
{
// Other type
}

=== JavaScript ===

There are 5 primitive data types in [http://en.wikipedia.org/wiki/JavaScript JavaScript]: string, number, boolean, null and undefined. <ref>http://oreilly.com/javascript/excerpts/learning-javascript/javascript-datatypes-variables.html JavaScript Data Types and Variables</ref>

For string, number and boolean values, there are corresponding classes just like in Java to create primitive objects which wrap the primitive values.

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class
|-
| string || String
|-
| number|| Number
|-
| boolean || Boolean
|}

In JavaScript, the primitive value is implicitly converted to a primitive object whenever someone tries to access a property or invoke a method on the primitive value and the primitive object is used in place of the primitive value. Since the object contains properties and methods, the use of primitive value as an object succeeds. After the property is accessed or the method is processed, the primitive object is no longer needed and hence discarded. The same is true for the other primitive types and their corresponding primitive objects.

Example:

var upperCaseString = "APPLE";
var lowerCaseString = upperCaseString.toLowerCase(); // assigns string "apple" to lowerCaseString
var s = "Hello"
var len = s.length; // assigns value 5 to len

=== Ruby ===

Since [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is a [http://www.jvoegele.com/software/langcomp.html pure object oriented] language, everything in Ruby is an object. Hence, all primitive types such as integers, floating point numbers, strings, are objects of a built-in class.<ref>http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html Classes in Ruby</ref>
All integers are primitive objects of either class [http://corelib.rubyonrails.org/classes/Fixnum.html Fixnum] or [http://corelib.rubyonrails.org/classes/Bignum.html Bignum]. A numeric literal with a decimal point and/or an exponent is a primitive object of [http://corelib.rubyonrails.org/classes/Float.html Float]. Single quoted literals and double quoted literals are primitive objects of [http://corelib.rubyonrails.org/classes/String.html String].

Example:

puts 10.class
puts 7.45.class
puts 'hi'.class
puts "hello".class

Output:

Fixnum
Float
String
String

This indicates that 10 is converted into an object of type Fixnum, 7.45 is converted into an object of type Float, 'hi' and "hello" are both converted into an object of type String.

Since all primitive types in Ruby are objects, we should be able to call methods of the Object class on them. Let us demonstrate the same for integer and float using the following example:

a=10
puts a.to_f
b=20.5
puts b.to_i

Output:
10.0
20

== Advantages of primitives ==

Advantages that use of primitive data type offers are as follows:
===Consistency===
Many of Java’s ideas originate in C and in C++, objects and primitive type also co-exist. When object-oriented constructs were grafted onto the C language, C’s data types remained as is. The motivation behind this is that Bjarne Stroustrup, C++’s designer, wanted to be as consistent as possible with the base C language, hoping to capitalize on programmers’ pre-C++ knowledge.
<ref>http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Primitive Types Considered Harmful</ref>

===Simplicity===
It is simple and intuitive to use primitive data type in basic utility.

Example:

1. Recurring number in a loop.(C++)

for(int i=0;i<10;i++)

2. Temp variables that record only one or two data.

===Performance===

====Time====
Processing primitive data type operation would be faster than processing composite data type in most cases. There are several reasons result in this differences.
*Hardware processing discrepancy
Many primitive data operations (like integer addition) can be performed as a single machine instruction while processing of composite data type would be transformed to a combination of primitive data types. eg. Some processors offer specific instructions to process sequences of characters with a single instruction.

Example:

[http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Difference in data fetching between primitive data and composite data in Java]

*Allocating and Garbage collection overhead for composite data type<ref>http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Performance_implications Garbage collection</ref><ref>http://www.ibm.com/developerworks/java/library/j-jtp01274/index.html Java theory and practice: Garbage collection and performance</ref>
There are many initialization operations for composite data type that will generate high overheads for example boxing and unboxing, constructors and destructors.Composite data type like class will also have garbage collection overheads that may be beyond the control of the programmer and can sometimes lead to performance problems. For example, commonly used stop-the-world garbage collectors, which pause program execution at arbitrary times, may make garbage collection inappropriate for some [http://en.wikipedia.org/wiki/Embedded_system embedded systems], high-performance [http://en.wikipedia.org/wiki/Server_(computing) server] software, and applications with [http://en.wikipedia.org/wiki/Real-time_computing real-time] needs.In the early days of Java technology, allocating objects got a high overheads. There were lots of articles advising developers to avoid creating temporary objects unnecessarily because allocation (and the corresponding garbage-collection overhead) was expensive. Although the costs have been greatly reduced nowadays. It still much slower than primitive data type which don’t have such troubles.

Example:

public class Test{
double dur1,dur2;
int N=100000000;
public void test1()
{
int a=1,b=1;
long startTime1 = System.currentTimeMillis();
for(int i=0;i<N;i++){
a=a+b;
}
long endTime1 = System.currentTimeMillis();
System.out.println(endTime1-startTime1);
}
public void test2(){
Integer c=new Integer(1);
Integer d=new Integer(1);
long startTime2 = System.currentTimeMillis();
for(int i=0;i<N;i++){
c=c+d;
}
long endTime2 = System.currentTimeMillis();
System.out.println(endTime2-startTime2)
}

'''Average execution time for test1 is: 1 mm'''

'''Average execution time for test2 is: 702mm'''

'''(test case number: 1000 times )'''

====Space====
Composite data type will cost more memory space than primitive data type in general. The reason is not only for the overheads generated by constructors, destructors etc, but also the feature of data alignment. <ref>http://en.wikipedia.org/wiki/Data_structure_alignment#Data_structure_padding Data structure alignment</ref>

Example of data alignment （C++）
struct compose
{
char name;
int a;
int b;
}

We all know the size of char is 1 byte, the size of int is 4 bytes. But the size of the struct compose as shown above is 12 bytes but not 9 bytes.

====Functionality====
Discussion of advantages and disadvantages should concerned the functionality you want to implement. For example if you want to operate a serials of int number. The performance of array may be better than int. <ref>http://cs.smith.edu/~thiebaut/ArtOfAssembly/CH05/CH05-2.html composite datatypes</ref>

[[File:1w1.gif]]

To access an element of an array, you need a function that converts an array index into the address of the indexed element. For a single dimension array, this function is very simple. It is
Element_Address = Base_Address + ((Index - Initial_Index) * Element_Size)
However, If you use five primitive data type to implement the same function. It may cost more time for the cpu to search the address of each data.

== Disdvantages of primitives ==

The various disadvantages of using the primitive data types are as follows:

===Cannot be extended===
We can use class or array to express the intricate data or functional structure. And programmers can create subtypes, modify their operations and even redefine them. In addition with the feature of class, programmers can make their variables unchangeable to any code outside the class, or make the implementation hidden to other code with call the methods. That means with composite data types, it will be more convenient for the programmers to handle sophisticated data and also make the code easier to maintain.

We can create a Person type in RUBY. We defined a “talk” method to make a Person can talk about himself. We also hope to only make the variable “motherland” changeable by the code outside this class.

Example：

class Person

def initialize( name, age=18 )
@name = name
@age = age
@motherland = "US"
end

def talk
puts "my name is "+@name+", age is "+@age.to_s
if @motherland == "US"
puts "I\'m American."
else
puts "I\'m International."
end
end
attr_writer :motherland
end

Later when we need to create a “Student” type, we can just inherent the “Person” type and make some adjustment based on our needs. Here we redefine the “talk” method to make a student talk in a different way.

class Student < Person

def talk
puts "I am a student. my name is "+@name+", age is "+@age.to_s
end
end

===Uncertainty===
Though it means more processing time, it is necessary for programmers to create composite type to handle the data whose length is too large or changing all the time. If we have a set or integers to maintain in memory, but the number of integers will change every minute, it will be impossible if we only use primitive types to handle. But we can make use of the “Arraylist” type in Java or other composite types. With the “Arraylist”, the programmers do not need to pay attention to the storage in the memory or the space it takes. The compiler of Java will reallocate more space automatically for the Arraylist if more elements are putted. <ref>http://docs.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html uncertainty of array</ref>

Here is an example for the insert and sorting methods of the Arraylist type in Java:

ArrayListaList=newArrayList();
aList.Add("a");
aList.Add("b");
aList.Add("c");
aList.Add("d");
aList.Add("e");
aList.Sort();

===Limitation===

For the primitive data types in most programming languages, there are some limits of the length. For example we can put an integer between -(2^16) and (2^16)-1 into an “int” in Java. That will be enough for some most of the cases but definitely not all of them. For example, the primitive types are not able for a scientific calculation if we need an accuracy on 10^-500. And a more extreme case is to calculate the last 100 numbers for the PI has a 100 million length.<ref>http://en.verysource.com/code/1285797_1/tlargefloat.h.html limitation of primitive</ref>

For these situations, the programmers usually need to create a composite data type by themselves. They can even redefine the operators (“+”, “-”) to make the super-long float also can make addition, subtraction with ordinary operators instead of method calling. For more details to create a super long float please see reference.

===cannot simplify the utility function associated with non primitive data types===

Most of the object oriented languages have certain utility functions associated with non primitive data types that ease their use as compared to primitive data types that do not have such functions. An especially useful example is the method of parsing integers in a specified radix in Java (Integer.parseInt). <ref>http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/Integer.html utility function associated with non primitive data types</ref>

parseInt("1100110", 2); //returns 102
parseInt("-0", 10); //returns 0
parseInt("-FF", 16); //returns -255
parseInt("99", 8); //throws a NumberFormatException

From the above examples, it is obvious that “Integer” type not just support ordinary methods an integer should have (such as Integer.equals), but also some more utility methods which are helpful for the programmers.

In addition, for some data structure which only take object but not primitive type (such as Vector in Java), it is necessary to box a primitive data type to a corresponding object. For example if a programmer needs to make use of a vector to store some integer, it is necessary to box the int first:

Vector　v=new Vector();
int k=121;
v.addElemt(new Integer(k));

== Conclusion ==

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T02:07:12Z

Yliu63: /* Time */

'''Primitive objects in object-oriented languages'''

== Introduction ==

In any programming language, the [http://en.wikipedia.org/wiki/Data_type data type] refers to the class of data which contains specific type or range of values. Data types are used along with variables used in the program. The data type tells us what kind of values the variable can store, what is the range of the values and how much space the values take in memory etc.

The [http://en.wikipedia.org/wiki/Primitive_data_type primitive data types] refer to the built-in data types which are supported by the programming language. Often 'data types' and 'primitive data types' are used interchangeably. But not all data types are primitive. Programming languages have some non-primitive data types or derived data types which are provided by the language by making use of its primitive data types.

The common built-in data types or primitive data types are integers, floating point numbers, characters, strings and boolean.
* Integers - Integers represent the whole numbers which can be positive or negative or zero, e.g. 9999, 0, -25, etc.
* Floating point numbers - Floating point numbers represent the numbers which are fractions or contain floating-decimal points, e.g. -3.002, 2.5, 22.0, etc.
* Characters - Characters represent any single letter, number, space, punctuation mark, or symbol that can be typed on a computer, e.g. 'a', '9', ' ', '!' , '\n', etc.
* Strings - Strings represent the sequences of characters or simply any text, e.g. "Hello!", "9 am to 6 pm", etc.
* Booleans - Booleans represent the true or false values. Sometimes, instead of true and false, 1 and 0 are used to represent the boolean values.

Many [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming] languages provide support for primitive data types while some object-oriented programming languages provide support for primitive objects along with primitive types.

== Definition ==

Primitive objects refer to the objects of built-in classes which provide more functionality than the primitive types. Some object-oriented programming languages provide support for only primitive objects (i.e., in such languages all primitive types are objects).

Different object-oriented programming languages implement these primitive data types and primitive objects in a different manner.

== Primitive objects in different OO languages ==
=== Java ===

In [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java], there are 8 primitive types: boolean, char, byte, short, int, long, float, and double. <ref>http://www.cafeaulait.org/course/week2/02.html Java's Primitive Data Types</ref>

For each of these primitive types, Java provides [http://en.wikipedia.org/wiki/Primitive_wrapper_class wrapper classes] to create primitive objects which wrap the primitive data values. A wrapper not only contains the primitive data value, but it also defines properties and methods that can be used to manipulate that data. In Java, the primitive values are not implicitly converted to primitive objects. Instead, methods are provided for doing explicit conversion.
The primitive objects are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack heap] in memory while the variables containing primitive values are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack stack].<ref>http://www.informit.com/articles/article.aspx?p=31755&seqNum=8 Stack and Heap memory</ref>

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class!! Size
|-
| boolean || Boolean || 1-bit
|-
| char || Character || 16-bit
|-
| byte || Byte || 8-bit
|-
| short || Short || 16-bit
|-
| int || Integer || 32-bit
|-
| long || Long || 64-bit
|-
| float || Float || 32-bit
|-
| double || Double || 64-bit
|}

Example:
int i = 10;
int ii = 20;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I+II);
System.out.println(I.equals(II));

Output:
30
false

To find out if these wrapper classes are primitive or not, we can use the isPrimitive() method.

System.out.println(INTEGER.TYPE.isPrimitive());
System.out.println(BOOLEAN.TYPE.isPrimitive());

Output:
true
true

In Java, the comparison operations work in the same way on the primitive objects as well as any other class objects but different on the primitive types. The == operator when used on objects checks whether they refer to the same object but when used on variables of primitive types checks whether they contain the same value.<ref>http://leepoint.net/notes-java/data/expressions/22compareobjects.html Comparisons in Java</ref>

Example:
int i = 10;
int ii = 10;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I==II);
System.out.println(i==ii);

Output:
false
true

=== C# ===

[http://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29 C#] is a [http://en.wikipedia.org/wiki/Strong_typing strongly typed] language, where it is necessary to declare the data type of a variable and also be aware of the data type conversion. C# provides a significant number of primitive data types.<ref>http://condor.depaul.edu/sjost/ndp/notes/cs1/CSDatatypes.htm C# Primitive Datatypes</ref><ref>http://www.java2s.com/Tutorial/CSharp/0040__Data-Type/PrimitivesinC.htm Primitives in C#</ref>

Because C# represents all primitive data types as objects, it is possible to call an object method on a primitive data type. For example:

static void Main()
{
int x = 7;
object o = x;
System.Console.WriteLine(o.ToString());
}

Some data types (e.g. Decimal and String) can appear like primitives at first sight, but are actually not. So it is important to exercise caution before making such assumptions. To test whether a particular type is a primitive or not you can use the property Type.IsPrimitive.

Consider the following example:

if (t.IsPrimitive) // where t is the type
{
// Is Primitive
} else if (t == typeof(Decimal))
{
// Is Decimal
} else if (t == typeof(String))
{
// Is String
} else
{
// Other type
}

=== JavaScript ===

There are 5 primitive data types in [http://en.wikipedia.org/wiki/JavaScript JavaScript]: string, number, boolean, null and undefined. <ref>http://oreilly.com/javascript/excerpts/learning-javascript/javascript-datatypes-variables.html JavaScript Data Types and Variables</ref>

For string, number and boolean values, there are corresponding classes just like in Java to create primitive objects which wrap the primitive values.

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class
|-
| string || String
|-
| number|| Number
|-
| boolean || Boolean
|}

In JavaScript, the primitive value is implicitly converted to a primitive object whenever someone tries to access a property or invoke a method on the primitive value and the primitive object is used in place of the primitive value. Since the object contains properties and methods, the use of primitive value as an object succeeds. After the property is accessed or the method is processed, the primitive object is no longer needed and hence discarded. The same is true for the other primitive types and their corresponding primitive objects.

Example:

var upperCaseString = "APPLE";
var lowerCaseString = upperCaseString.toLowerCase(); // assigns string "apple" to lowerCaseString
var s = "Hello"
var len = s.length; // assigns value 5 to len

=== Ruby ===

Since [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is a [http://www.jvoegele.com/software/langcomp.html pure object oriented] language, everything in Ruby is an object. Hence, all primitive types such as integers, floating point numbers, strings, are objects of a built-in class.<ref>http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html Classes in Ruby</ref>
All integers are primitive objects of either class [http://corelib.rubyonrails.org/classes/Fixnum.html Fixnum] or [http://corelib.rubyonrails.org/classes/Bignum.html Bignum]. A numeric literal with a decimal point and/or an exponent is a primitive object of [http://corelib.rubyonrails.org/classes/Float.html Float]. Single quoted literals and double quoted literals are primitive objects of [http://corelib.rubyonrails.org/classes/String.html String].

Example:

puts 10.class
puts 7.45.class
puts 'hi'.class
puts "hello".class

Output:

Fixnum
Float
String
String

This indicates that 10 is converted into an object of type Fixnum, 7.45 is converted into an object of type Float, 'hi' and "hello" are both converted into an object of type String.

Since all primitive types in Ruby are objects, we should be able to call methods of the Object class on them. Let us demonstrate the same for integer and float using the following example:

a=10
puts a.to_f
b=20.5
puts b.to_i

Output:
10.0
20

== Advantages of primitives ==

Advantages that use of primitive data type offers are as follows:
===Consistency===
Many of Java’s ideas originate in C and in C++, objects and primitive type also co-exist. When object-oriented constructs were grafted onto the C language, C’s data types remained as is. The motivation behind this is that Bjarne Stroustrup, C++’s designer, wanted to be as consistent as possible with the base C language, hoping to capitalize on programmers’ pre-C++ knowledge.
<ref>http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Primitive Types Considered Harmful</ref>

===Simplicity===
It is simple and intuitive to use primitive data type in basic utility.

Example:

1. Recurring number in a loop.(C++)

for(int i=0;i<10;i++)

2. Temp variables that record only one or two data.

===Performance===

====Time====
Processing primitive data type operation would be faster than processing composite data type in most cases. There are several reasons result in this differences.
*Hardware processing discrepancy
Many primitive data operations (like integer addition) can be performed as a single machine instruction while processing of composite data type would be transformed to a combination of primitive data types. eg. Some processors offer specific instructions to process sequences of characters with a single instruction.

Example:

[http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Difference in data fetching between primitive data and composite data in Java]

*Allocating and Garbage collection overhead for composite data type<ref>http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Performance_implications garbage collection</ref><ref>http://www.ibm.com/developerworks/java/library/j-jtp01274/index.html Java theory and practice: Garbage collection and performance</ref>
There are many initialization operations for composite data type that will generate high overheads for example boxing and unboxing, constructors and destructors.Composite data type like class will also have garbage collection overheads that may be beyond the control of the programmer and can sometimes lead to performance problems. For example, commonly used stop-the-world garbage collectors, which pause program execution at arbitrary times, may make garbage collection inappropriate for some [http://en.wikipedia.org/wiki/Embedded_system embedded systems], high-performance [http://en.wikipedia.org/wiki/Server_(computing) server] software, and applications with [http://en.wikipedia.org/wiki/Real-time_computing real-time] needs.In the early days of Java technology, allocating objects got a high overheads. There were lots of articles advising developers to avoid creating temporary objects unnecessarily because allocation (and the corresponding garbage-collection overhead) was expensive. Although the costs have been greatly reduced nowadays. It still much slower than primitive data type which don’t have such troubles.

Example:

public class Test{
double dur1,dur2;
int N=100000000;
public void test1()
{
int a=1,b=1;
long startTime1 = System.currentTimeMillis();
for(int i=0;i<N;i++){
a=a+b;
}
long endTime1 = System.currentTimeMillis();
System.out.println(endTime1-startTime1);
}
public void test2(){
Integer c=new Integer(1);
Integer d=new Integer(1);
long startTime2 = System.currentTimeMillis();
for(int i=0;i<N;i++){
c=c+d;
}
long endTime2 = System.currentTimeMillis();
System.out.println(endTime2-startTime2)
}

'''Average execution time for test1 is: 1 mm'''

'''Average execution time for test2 is: 702mm'''

'''(test case number: 1000 times )'''

====Space====
Composite data type will cost more memory space than primitive data type in general. The reason is not only for the overheads generated by constructors, destructors etc, but also the feature of data alignment. <ref>http://en.wikipedia.org/wiki/Data_structure_alignment#Data_structure_padding Data structure alignment</ref>

Example of data alignment （C++）
struct compose
{
char name;
int a;
int b;
}

We all know the size of char is 1 byte, the size of int is 4 bytes. But the size of the struct compose as shown above is 12 bytes but not 9 bytes.

====Functionality====
Discussion of advantages and disadvantages should concerned the functionality you want to implement. For example if you want to operate a serials of int number. The performance of array may be better than int. <ref>http://cs.smith.edu/~thiebaut/ArtOfAssembly/CH05/CH05-2.html composite datatypes</ref>

[[File:1w1.gif]]

To access an element of an array, you need a function that converts an array index into the address of the indexed element. For a single dimension array, this function is very simple. It is
Element_Address = Base_Address + ((Index - Initial_Index) * Element_Size)
However, If you use five primitive data type to implement the same function. It may cost more time for the cpu to search the address of each data.

== Disdvantages of primitives ==

The various disadvantages of using the primitive data types are as follows:

===Cannot be extended===
We can use class or array to express the intricate data or functional structure. And programmers can create subtypes, modify their operations and even redefine them. In addition with the feature of class, programmers can make their variables unchangeable to any code outside the class, or make the implementation hidden to other code with call the methods. That means with composite data types, it will be more convenient for the programmers to handle sophisticated data and also make the code easier to maintain.

We can create a Person type in RUBY. We defined a “talk” method to make a Person can talk about himself. We also hope to only make the variable “motherland” changeable by the code outside this class.

Example：

class Person

def initialize( name, age=18 )
@name = name
@age = age
@motherland = "US"
end

def talk
puts "my name is "+@name+", age is "+@age.to_s
if @motherland == "US"
puts "I\'m American."
else
puts "I\'m International."
end
end
attr_writer :motherland
end

Later when we need to create a “Student” type, we can just inherent the “Person” type and make some adjustment based on our needs. Here we redefine the “talk” method to make a student talk in a different way.

== Conclusion ==

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T01:49:14Z

Yliu63: /* Consistency */

'''Primitive objects in object-oriented languages'''

== Introduction ==

In any programming language, the [http://en.wikipedia.org/wiki/Data_type data type] refers to the class of data which contains specific type or range of values. Data types are used along with variables used in the program. The data type tells us what kind of values the variable can store, what is the range of the values and how much space the values take in memory etc.

The [http://en.wikipedia.org/wiki/Primitive_data_type primitive data types] refer to the built-in data types which are supported by the programming language. Often 'data types' and 'primitive data types' are used interchangeably. But not all data types are primitive. Programming languages have some non-primitive data types or derived data types which are provided by the language by making use of its primitive data types.

The common built-in data types or primitive data types are integers, floating point numbers, characters, strings and boolean.
* Integers - Integers represent the whole numbers which can be positive or negative or zero, e.g. 9999, 0, -25, etc.
* Floating point numbers - Floating point numbers represent the numbers which are fractions or contain floating-decimal points, e.g. -3.002, 2.5, 22.0, etc.
* Characters - Characters represent any single letter, number, space, punctuation mark, or symbol that can be typed on a computer, e.g. 'a', '9', ' ', '!' , '\n', etc.
* Strings - Strings represent the sequences of characters or simply any text, e.g. "Hello!", "9 am to 6 pm", etc.
* Booleans - Booleans represent the true or false values. Sometimes, instead of true and false, 1 and 0 are used to represent the boolean values.

Many [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming] languages provide support for primitive data types while some object-oriented programming languages provide support for primitive objects along with primitive types.

== Definition ==

Primitive objects refer to the objects of built-in classes which provide more functionality than the primitive types. Some object-oriented programming languages provide support for only primitive objects (i.e., in such languages all primitive types are objects).

Different object-oriented programming languages implement these primitive data types and primitive objects in a different manner.

== Primitive objects in different OO languages ==
=== Java ===

In [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java], there are 8 primitive types: boolean, char, byte, short, int, long, float, and double. <ref>http://www.cafeaulait.org/course/week2/02.html Java's Primitive Data Types</ref>

For each of these primitive types, Java provides [http://en.wikipedia.org/wiki/Primitive_wrapper_class wrapper classes] to create primitive objects which wrap the primitive data values. A wrapper not only contains the primitive data value, but it also defines properties and methods that can be used to manipulate that data. In Java, the primitive values are not implicitly converted to primitive objects. Instead, methods are provided for doing explicit conversion.
The primitive objects are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack heap] in memory while the variables containing primitive values are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack stack].<ref>http://www.informit.com/articles/article.aspx?p=31755&seqNum=8 Stack and Heap memory</ref>

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class!! Size
|-
| boolean || Boolean || 1-bit
|-
| char || Character || 16-bit
|-
| byte || Byte || 8-bit
|-
| short || Short || 16-bit
|-
| int || Integer || 32-bit
|-
| long || Long || 64-bit
|-
| float || Float || 32-bit
|-
| double || Double || 64-bit
|}

Example:
int i = 10;
int ii = 20;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I+II);
System.out.println(I.equals(II));

Output:
30
false

To find out if these wrapper classes are primitive or not, we can use the isPrimitive() method.

System.out.println(INTEGER.TYPE.isPrimitive());
System.out.println(BOOLEAN.TYPE.isPrimitive());

Output:
true
true

In Java, the comparison operations work in the same way on the primitive objects as well as any other class objects but different on the primitive types. The == operator when used on objects checks whether they refer to the same object but when used on variables of primitive types checks whether they contain the same value.<ref>http://leepoint.net/notes-java/data/expressions/22compareobjects.html Comparisons in Java</ref>

Example:
int i = 10;
int ii = 10;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I==II);
System.out.println(i==ii);

Output:
false
true

=== C# ===

[http://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29 C#] is a [http://en.wikipedia.org/wiki/Strong_typing strongly typed] language, where it is necessary to declare the data type of a variable and also be aware of the data type conversion. C# provides a significant number of primitive data types.<ref>http://condor.depaul.edu/sjost/ndp/notes/cs1/CSDatatypes.htm C# Primitive Datatypes</ref><ref>http://www.java2s.com/Tutorial/CSharp/0040__Data-Type/PrimitivesinC.htm Primitives in C#</ref>

Because C# represents all primitive data types as objects, it is possible to call an object method on a primitive data type. For example:

static void Main()
{
int x = 7;
object o = x;
System.Console.WriteLine(o.ToString());
}

Some data types (e.g. Decimal and String) can appear like primitives at first sight, but are actually not. So it is important to exercise caution before making such assumptions. To test whether a particular type is a primitive or not you can use the property Type.IsPrimitive.

Consider the following example:

if (t.IsPrimitive) // where t is the type
{
// Is Primitive
} else if (t == typeof(Decimal))
{
// Is Decimal
} else if (t == typeof(String))
{
// Is String
} else
{
// Other type
}

=== JavaScript ===

There are 5 primitive data types in [http://en.wikipedia.org/wiki/JavaScript JavaScript]: string, number, boolean, null and undefined. <ref>http://oreilly.com/javascript/excerpts/learning-javascript/javascript-datatypes-variables.html JavaScript Data Types and Variables</ref>

For string, number and boolean values, there are corresponding classes just like in Java to create primitive objects which wrap the primitive values.

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class
|-
| string || String
|-
| number|| Number
|-
| boolean || Boolean
|}

In JavaScript, the primitive value is implicitly converted to a primitive object whenever someone tries to access a property or invoke a method on the primitive value and the primitive object is used in place of the primitive value. Since the object contains properties and methods, the use of primitive value as an object succeeds. After the property is accessed or the method is processed, the primitive object is no longer needed and hence discarded. The same is true for the other primitive types and their corresponding primitive objects.

Example:

var upperCaseString = "APPLE";
var lowerCaseString = upperCaseString.toLowerCase(); // assigns string "apple" to lowerCaseString
var s = "Hello"
var len = s.length; // assigns value 5 to len

=== Ruby ===

Since [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is a [http://www.jvoegele.com/software/langcomp.html pure object oriented] language, everything in Ruby is an object. Hence, all primitive types such as integers, floating point numbers, strings, are objects of a built-in class.<ref>http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html Classes in Ruby</ref>
All integers are primitive objects of either class [http://corelib.rubyonrails.org/classes/Fixnum.html Fixnum] or [http://corelib.rubyonrails.org/classes/Bignum.html Bignum]. A numeric literal with a decimal point and/or an exponent is a primitive object of [http://corelib.rubyonrails.org/classes/Float.html Float]. Single quoted literals and double quoted literals are primitive objects of [http://corelib.rubyonrails.org/classes/String.html String].

Example:

puts 10.class
puts 7.45.class
puts 'hi'.class
puts "hello".class

Output:

Fixnum
Float
String
String

This indicates that 10 is converted into an object of type Fixnum, 7.45 is converted into an object of type Float, 'hi' and "hello" are both converted into an object of type String.

Since all primitive types in Ruby are objects, we should be able to call methods of the Object class on them. Let us demonstrate the same for integer and float using the following example:

a=10
puts a.to_f
b=20.5
puts b.to_i

Output:
10.0
20

== Advantages of primitives ==

Advantages that use of primitive data type offers are as follows:
===Consistency===
Many of Java’s ideas originate in C and in C++, objects and primitive type also co-exist. When object-oriented constructs were grafted onto the C language, C’s data types remained as is. The motivation behind this is that Bjarne Stroustrup, C++’s designer, wanted to be as consistent as possible with the base C language, hoping to capitalize on programmers’ pre-C++ knowledge.
<ref>http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Primitive Types Considered Harmful</ref>

===Simplicity===
It is simple and intuitive to use primitive data type in basic utility.

Example:

1. Recurring number in a loop.(C++)

for(int i=0;i<10;i++)

2. Temp variables that record only one or two data.

===Performance===

====Time====
Processing primitive data type operation would be faster than processing composite data type in most cases. There are several reasons result in this differences.
*Hardware processing discrepancy
Many primitive data operations (like integer addition) can be performed as a single machine instruction while processing of composite data type would be transformed to a combination of primitive data types. eg. Some processors offer specific instructions to process sequences of characters with a single instruction.

Example:

[http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Difference in data fetching between primitive data and composite data in Java]

*Initialization overheads for composite data type
There are many initialization operations for composite data type. for example boxing and unboxing, constructors and destructors.
*Allocating and Garbage collection overhead for composite data type<ref>http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Performance_implications garbage collection</ref><ref>http://www.ibm.com/developerworks/java/library/j-jtp01274/index.html Java theory and practice: Garbage collection and performance</ref>
Composite data type like class will have allocation and garbage collection overhead that may be beyond the control of the programmer and can sometimes lead to performance problems. For example, commonly used stop-the-world garbage collectors, which pause program execution at arbitrary times, may make garbage collection inappropriate for some [http://en.wikipedia.org/wiki/Embedded_system embedded systems], high-performance [http://en.wikipedia.org/wiki/Server_(computing) server] software, and applications with [http://en.wikipedia.org/wiki/Real-time_computing real-time] needs.In the early days of Java technology, allocating objects got a high overheads. There were lots of articles advising developers to avoid creating temporary objects unnecessarily because allocation (and the corresponding garbage-collection overhead) was expensive. Although the costs have been greatly reduced nowadays. It still much slower than primitive data type which don’t have such troubles.

Example:

public class Test{
double dur1,dur2;
int N=100000000;
public void test1()
{
int a=1,b=1;
long startTime1 = System.currentTimeMillis();
for(int i=0;i<N;i++){
a=a+b;
}
long endTime1 = System.currentTimeMillis();
System.out.println(endTime1-startTime1);
}
public void test2(){
Integer c=new Integer(1);
Integer d=new Integer(1);
long startTime2 = System.currentTimeMillis();
for(int i=0;i<N;i++){
c=c+d;
}
long endTime2 = System.currentTimeMillis();
System.out.println(endTime2-startTime2)
}

'''Average execution time for test1 is: 1 mm'''

'''Average execution time for test2 is: 702mm'''

'''(test case number: 1000 times )'''

====Space====
Composite data type will cost more memory space than primitive data type in general. The reason is not only for the overheads generated by constructors, destructors etc, but also the feature of data alignment. <ref>http://en.wikipedia.org/wiki/Data_structure_alignment#Data_structure_padding Data structure alignment</ref>

Example of data alignment （C++）
struct compose
{
char name;
int a;
int b;
}

We all know the size of char is 1 byte, the size of int is 4 bytes. But the size of the struct compose as shown above is 12 bytes but not 9 bytes.

====Functionality====
Discussion of advantages and disadvantages should concerned the functionality you want to implement. For example if you want to operate a serials of int number. The performance of array may be better than int. <ref>http://cs.smith.edu/~thiebaut/ArtOfAssembly/CH05/CH05-2.html composite datatypes</ref>

[[File:1w1.gif]]

To access an element of an array, you need a function that converts an array index into the address of the indexed element. For a single dimension array, this function is very simple. It is
Element_Address = Base_Address + ((Index - Initial_Index) * Element_Size)
However, If you use five primitive data type to implement the same function. It may cost more time for the cpu to search the address of each data.

== Conclusion ==

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T01:47:26Z

Yliu63: /* [Consistency][http://www.research.ibm.com/people/a/alpert/ptch/ptch.html] */

'''Primitive objects in object-oriented languages'''

== Introduction ==

In any programming language, the [http://en.wikipedia.org/wiki/Data_type data type] refers to the class of data which contains specific type or range of values. Data types are used along with variables used in the program. The data type tells us what kind of values the variable can store, what is the range of the values and how much space the values take in memory etc.

The [http://en.wikipedia.org/wiki/Primitive_data_type primitive data types] refer to the built-in data types which are supported by the programming language. Often 'data types' and 'primitive data types' are used interchangeably. But not all data types are primitive. Programming languages have some non-primitive data types or derived data types which are provided by the language by making use of its primitive data types.

The common built-in data types or primitive data types are integers, floating point numbers, characters, strings and boolean.
* Integers - Integers represent the whole numbers which can be positive or negative or zero, e.g. 9999, 0, -25, etc.
* Floating point numbers - Floating point numbers represent the numbers which are fractions or contain floating-decimal points, e.g. -3.002, 2.5, 22.0, etc.
* Characters - Characters represent any single letter, number, space, punctuation mark, or symbol that can be typed on a computer, e.g. 'a', '9', ' ', '!' , '\n', etc.
* Strings - Strings represent the sequences of characters or simply any text, e.g. "Hello!", "9 am to 6 pm", etc.
* Booleans - Booleans represent the true or false values. Sometimes, instead of true and false, 1 and 0 are used to represent the boolean values.

Many [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming] languages provide support for primitive data types while some object-oriented programming languages provide support for primitive objects along with primitive types.

== Definition ==

Primitive objects refer to the objects of built-in classes which provide more functionality than the primitive types. Some object-oriented programming languages provide support for only primitive objects (i.e., in such languages all primitive types are objects).

Different object-oriented programming languages implement these primitive data types and primitive objects in a different manner.

== Primitive objects in different OO languages ==
=== Java ===

In [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java], there are 8 primitive types: boolean, char, byte, short, int, long, float, and double. <ref>http://www.cafeaulait.org/course/week2/02.html Java's Primitive Data Types</ref>

For each of these primitive types, Java provides [http://en.wikipedia.org/wiki/Primitive_wrapper_class wrapper classes] to create primitive objects which wrap the primitive data values. A wrapper not only contains the primitive data value, but it also defines properties and methods that can be used to manipulate that data. In Java, the primitive values are not implicitly converted to primitive objects. Instead, methods are provided for doing explicit conversion.
The primitive objects are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack heap] in memory while the variables containing primitive values are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack stack].<ref>http://www.informit.com/articles/article.aspx?p=31755&seqNum=8 Stack and Heap memory</ref>

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class!! Size
|-
| boolean || Boolean || 1-bit
|-
| char || Character || 16-bit
|-
| byte || Byte || 8-bit
|-
| short || Short || 16-bit
|-
| int || Integer || 32-bit
|-
| long || Long || 64-bit
|-
| float || Float || 32-bit
|-
| double || Double || 64-bit
|}

Example:
int i = 10;
int ii = 20;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I+II);
System.out.println(I.equals(II));

Output:
30
false

To find out if these wrapper classes are primitive or not, we can use the isPrimitive() method.

System.out.println(INTEGER.TYPE.isPrimitive());
System.out.println(BOOLEAN.TYPE.isPrimitive());

Output:
true
true

In Java, the comparison operations work in the same way on the primitive objects as well as any other class objects but different on the primitive types. The == operator when used on objects checks whether they refer to the same object but when used on variables of primitive types checks whether they contain the same value.<ref>http://leepoint.net/notes-java/data/expressions/22compareobjects.html Comparisons in Java</ref>

Example:
int i = 10;
int ii = 10;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I==II);
System.out.println(i==ii);

Output:
false
true

=== C# ===

[http://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29 C#] is a [http://en.wikipedia.org/wiki/Strong_typing strongly typed] language, where it is necessary to declare the data type of a variable and also be aware of the data type conversion. C# provides a significant number of primitive data types.<ref>http://condor.depaul.edu/sjost/ndp/notes/cs1/CSDatatypes.htm C# Primitive Datatypes</ref><ref>http://www.java2s.com/Tutorial/CSharp/0040__Data-Type/PrimitivesinC.htm Primitives in C#</ref>

Because C# represents all primitive data types as objects, it is possible to call an object method on a primitive data type. For example:

static void Main()
{
int x = 7;
object o = x;
System.Console.WriteLine(o.ToString());
}

Some data types (e.g. Decimal and String) can appear like primitives at first sight, but are actually not. So it is important to exercise caution before making such assumptions. To test whether a particular type is a primitive or not you can use the property Type.IsPrimitive.

Consider the following example:

if (t.IsPrimitive) // where t is the type
{
// Is Primitive
} else if (t == typeof(Decimal))
{
// Is Decimal
} else if (t == typeof(String))
{
// Is String
} else
{
// Other type
}

=== JavaScript ===

There are 5 primitive data types in [http://en.wikipedia.org/wiki/JavaScript JavaScript]: string, number, boolean, null and undefined. <ref>http://oreilly.com/javascript/excerpts/learning-javascript/javascript-datatypes-variables.html JavaScript Data Types and Variables</ref>

For string, number and boolean values, there are corresponding classes just like in Java to create primitive objects which wrap the primitive values.

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class
|-
| string || String
|-
| number|| Number
|-
| boolean || Boolean
|}

In JavaScript, the primitive value is implicitly converted to a primitive object whenever someone tries to access a property or invoke a method on the primitive value and the primitive object is used in place of the primitive value. Since the object contains properties and methods, the use of primitive value as an object succeeds. After the property is accessed or the method is processed, the primitive object is no longer needed and hence discarded. The same is true for the other primitive types and their corresponding primitive objects.

Example:

var upperCaseString = "APPLE";
var lowerCaseString = upperCaseString.toLowerCase(); // assigns string "apple" to lowerCaseString
var s = "Hello"
var len = s.length; // assigns value 5 to len

=== Ruby ===

Since [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is a [http://www.jvoegele.com/software/langcomp.html pure object oriented] language, everything in Ruby is an object. Hence, all primitive types such as integers, floating point numbers, strings, are objects of a built-in class.<ref>http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html Classes in Ruby</ref>
All integers are primitive objects of either class [http://corelib.rubyonrails.org/classes/Fixnum.html Fixnum] or [http://corelib.rubyonrails.org/classes/Bignum.html Bignum]. A numeric literal with a decimal point and/or an exponent is a primitive object of [http://corelib.rubyonrails.org/classes/Float.html Float]. Single quoted literals and double quoted literals are primitive objects of [http://corelib.rubyonrails.org/classes/String.html String].

Example:

puts 10.class
puts 7.45.class
puts 'hi'.class
puts "hello".class

Output:

Fixnum
Float
String
String

This indicates that 10 is converted into an object of type Fixnum, 7.45 is converted into an object of type Float, 'hi' and "hello" are both converted into an object of type String.

Since all primitive types in Ruby are objects, we should be able to call methods of the Object class on them. Let us demonstrate the same for integer and float using the following example:

a=10
puts a.to_f
b=20.5
puts b.to_i

Output:
10.0
20

== Advantages of primitives ==

Advantages that use of primitive data type offers are as follows:
===Consistency===
Many of Java’s ideas originate in C++ and in C++, objects and primitive type also co-exist. When object-oriented constructs were grafted onto the C language, C’s data types remained as is. The motivation behind this is that Bjarne Stroustrup, C++’s designer, wanted to be as consistent as possible with the base C language, hoping to capitalize on programmers’ pre-C++ knowledge.

===Simplicity===
It is simple and intuitive to use primitive data type in basic utility.

Example:

1. Recurring number in a loop.(C++)

for(int i=0;i<10;i++)

2. Temp variables that record only one or two data.

===Performance===

====Time====
Processing primitive data type operation would be faster than processing composite data type in most cases. There are several reasons result in this differences.
*Hardware processing discrepancy
Many primitive data operations (like integer addition) can be performed as a single machine instruction while processing of composite data type would be transformed to a combination of primitive data types. eg. Some processors offer specific instructions to process sequences of characters with a single instruction.

Example:

[http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Difference in data fetching between primitive data and composite data in Java]

*Initialization overheads for composite data type
There are many initialization operations for composite data type. for example boxing and unboxing, constructors and destructors.
*Allocating and Garbage collection overhead for composite data type<ref>http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Performance_implications garbage collection</ref><ref>http://www.ibm.com/developerworks/java/library/j-jtp01274/index.html Java theory and practice: Garbage collection and performance</ref>
Composite data type like class will have allocation and garbage collection overhead that may be beyond the control of the programmer and can sometimes lead to performance problems. For example, commonly used stop-the-world garbage collectors, which pause program execution at arbitrary times, may make garbage collection inappropriate for some [http://en.wikipedia.org/wiki/Embedded_system embedded systems], high-performance [http://en.wikipedia.org/wiki/Server_(computing) server] software, and applications with [http://en.wikipedia.org/wiki/Real-time_computing real-time] needs.In the early days of Java technology, allocating objects got a high overheads. There were lots of articles advising developers to avoid creating temporary objects unnecessarily because allocation (and the corresponding garbage-collection overhead) was expensive. Although the costs have been greatly reduced nowadays. It still much slower than primitive data type which don’t have such troubles.

Example:

public class Test{
double dur1,dur2;
int N=100000000;
public void test1()
{
int a=1,b=1;
long startTime1 = System.currentTimeMillis();
for(int i=0;i<N;i++){
a=a+b;
}
long endTime1 = System.currentTimeMillis();
System.out.println(endTime1-startTime1);
}
public void test2(){
Integer c=new Integer(1);
Integer d=new Integer(1);
long startTime2 = System.currentTimeMillis();
for(int i=0;i<N;i++){
c=c+d;
}
long endTime2 = System.currentTimeMillis();
System.out.println(endTime2-startTime2)
}

'''Average execution time for test1 is: 1 mm'''

'''Average execution time for test2 is: 702mm'''

'''(test case number: 1000 times )'''

====Space====
Composite data type will cost more memory space than primitive data type in general. The reason is not only for the overheads generated by constructors, destructors etc, but also the feature of data alignment. <ref>http://en.wikipedia.org/wiki/Data_structure_alignment#Data_structure_padding Data structure alignment</ref>

Example of data alignment （C++）
struct compose
{
char name;
int a;
int b;
}

We all know the size of char is 1 byte, the size of int is 4 bytes. But the size of the struct compose as shown above is 12 bytes but not 9 bytes.

====Functionality====
Discussion of advantages and disadvantages should concerned the functionality you want to implement. For example if you want to operate a serials of int number. The performance of array may be better than int. <ref>http://cs.smith.edu/~thiebaut/ArtOfAssembly/CH05/CH05-2.html composite datatypes</ref>

[[File:1w1.gif]]

To access an element of an array, you need a function that converts an array index into the address of the indexed element. For a single dimension array, this function is very simple. It is
Element_Address = Base_Address + ((Index - Initial_Index) * Element_Size)
However, If you use five primitive data type to implement the same function. It may cost more time for the cpu to search the address of each data.

== Conclusion ==

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T01:47:01Z

Yliu63: /* Consistency */

'''Primitive objects in object-oriented languages'''

== Introduction ==

In any programming language, the [http://en.wikipedia.org/wiki/Data_type data type] refers to the class of data which contains specific type or range of values. Data types are used along with variables used in the program. The data type tells us what kind of values the variable can store, what is the range of the values and how much space the values take in memory etc.

The [http://en.wikipedia.org/wiki/Primitive_data_type primitive data types] refer to the built-in data types which are supported by the programming language. Often 'data types' and 'primitive data types' are used interchangeably. But not all data types are primitive. Programming languages have some non-primitive data types or derived data types which are provided by the language by making use of its primitive data types.

The common built-in data types or primitive data types are integers, floating point numbers, characters, strings and boolean.
* Integers - Integers represent the whole numbers which can be positive or negative or zero, e.g. 9999, 0, -25, etc.
* Floating point numbers - Floating point numbers represent the numbers which are fractions or contain floating-decimal points, e.g. -3.002, 2.5, 22.0, etc.
* Characters - Characters represent any single letter, number, space, punctuation mark, or symbol that can be typed on a computer, e.g. 'a', '9', ' ', '!' , '\n', etc.
* Strings - Strings represent the sequences of characters or simply any text, e.g. "Hello!", "9 am to 6 pm", etc.
* Booleans - Booleans represent the true or false values. Sometimes, instead of true and false, 1 and 0 are used to represent the boolean values.

Many [http://en.wikipedia.org/wiki/Object-oriented_programming object-oriented programming] languages provide support for primitive data types while some object-oriented programming languages provide support for primitive objects along with primitive types.

== Definition ==

Primitive objects refer to the objects of built-in classes which provide more functionality than the primitive types. Some object-oriented programming languages provide support for only primitive objects (i.e., in such languages all primitive types are objects).

Different object-oriented programming languages implement these primitive data types and primitive objects in a different manner.

== Primitive objects in different OO languages ==
=== Java ===

In [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java], there are 8 primitive types: boolean, char, byte, short, int, long, float, and double. <ref>http://www.cafeaulait.org/course/week2/02.html Java's Primitive Data Types</ref>

For each of these primitive types, Java provides [http://en.wikipedia.org/wiki/Primitive_wrapper_class wrapper classes] to create primitive objects which wrap the primitive data values. A wrapper not only contains the primitive data value, but it also defines properties and methods that can be used to manipulate that data. In Java, the primitive values are not implicitly converted to primitive objects. Instead, methods are provided for doing explicit conversion.
The primitive objects are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack heap] in memory while the variables containing primitive values are stored on [http://www.maxi-pedia.com/what+is+heap+and+stack stack].<ref>http://www.informit.com/articles/article.aspx?p=31755&seqNum=8 Stack and Heap memory</ref>

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class!! Size
|-
| boolean || Boolean || 1-bit
|-
| char || Character || 16-bit
|-
| byte || Byte || 8-bit
|-
| short || Short || 16-bit
|-
| int || Integer || 32-bit
|-
| long || Long || 64-bit
|-
| float || Float || 32-bit
|-
| double || Double || 64-bit
|}

Example:
int i = 10;
int ii = 20;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I+II);
System.out.println(I.equals(II));

Output:
30
false

To find out if these wrapper classes are primitive or not, we can use the isPrimitive() method.

System.out.println(INTEGER.TYPE.isPrimitive());
System.out.println(BOOLEAN.TYPE.isPrimitive());

Output:
true
true

In Java, the comparison operations work in the same way on the primitive objects as well as any other class objects but different on the primitive types. The == operator when used on objects checks whether they refer to the same object but when used on variables of primitive types checks whether they contain the same value.<ref>http://leepoint.net/notes-java/data/expressions/22compareobjects.html Comparisons in Java</ref>

Example:
int i = 10;
int ii = 10;
Integer I = new Integer(i);
Integer II = new Integer(ii);
System.out.println(I==II);
System.out.println(i==ii);

Output:
false
true

=== C# ===

[http://en.wikipedia.org/wiki/C_Sharp_%28programming_language%29 C#] is a [http://en.wikipedia.org/wiki/Strong_typing strongly typed] language, where it is necessary to declare the data type of a variable and also be aware of the data type conversion. C# provides a significant number of primitive data types.<ref>http://condor.depaul.edu/sjost/ndp/notes/cs1/CSDatatypes.htm C# Primitive Datatypes</ref><ref>http://www.java2s.com/Tutorial/CSharp/0040__Data-Type/PrimitivesinC.htm Primitives in C#</ref>

Because C# represents all primitive data types as objects, it is possible to call an object method on a primitive data type. For example:

static void Main()
{
int x = 7;
object o = x;
System.Console.WriteLine(o.ToString());
}

Some data types (e.g. Decimal and String) can appear like primitives at first sight, but are actually not. So it is important to exercise caution before making such assumptions. To test whether a particular type is a primitive or not you can use the property Type.IsPrimitive.

Consider the following example:

if (t.IsPrimitive) // where t is the type
{
// Is Primitive
} else if (t == typeof(Decimal))
{
// Is Decimal
} else if (t == typeof(String))
{
// Is String
} else
{
// Other type
}

=== JavaScript ===

There are 5 primitive data types in [http://en.wikipedia.org/wiki/JavaScript JavaScript]: string, number, boolean, null and undefined. <ref>http://oreilly.com/javascript/excerpts/learning-javascript/javascript-datatypes-variables.html JavaScript Data Types and Variables</ref>

For string, number and boolean values, there are corresponding classes just like in Java to create primitive objects which wrap the primitive values.

{| class="wikitable"
|+
|-
! Primitive Type !! Wrapper Class
|-
| string || String
|-
| number|| Number
|-
| boolean || Boolean
|}

In JavaScript, the primitive value is implicitly converted to a primitive object whenever someone tries to access a property or invoke a method on the primitive value and the primitive object is used in place of the primitive value. Since the object contains properties and methods, the use of primitive value as an object succeeds. After the property is accessed or the method is processed, the primitive object is no longer needed and hence discarded. The same is true for the other primitive types and their corresponding primitive objects.

Example:

var upperCaseString = "APPLE";
var lowerCaseString = upperCaseString.toLowerCase(); // assigns string "apple" to lowerCaseString
var s = "Hello"
var len = s.length; // assigns value 5 to len

=== Ruby ===

Since [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] is a [http://www.jvoegele.com/software/langcomp.html pure object oriented] language, everything in Ruby is an object. Hence, all primitive types such as integers, floating point numbers, strings, are objects of a built-in class.<ref>http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html Classes in Ruby</ref>
All integers are primitive objects of either class [http://corelib.rubyonrails.org/classes/Fixnum.html Fixnum] or [http://corelib.rubyonrails.org/classes/Bignum.html Bignum]. A numeric literal with a decimal point and/or an exponent is a primitive object of [http://corelib.rubyonrails.org/classes/Float.html Float]. Single quoted literals and double quoted literals are primitive objects of [http://corelib.rubyonrails.org/classes/String.html String].

Example:

puts 10.class
puts 7.45.class
puts 'hi'.class
puts "hello".class

Output:

Fixnum
Float
String
String

This indicates that 10 is converted into an object of type Fixnum, 7.45 is converted into an object of type Float, 'hi' and "hello" are both converted into an object of type String.

Since all primitive types in Ruby are objects, we should be able to call methods of the Object class on them. Let us demonstrate the same for integer and float using the following example:

a=10
puts a.to_f
b=20.5
puts b.to_i

Output:
10.0
20

== Advantages of primitives ==

Advantages that use of primitive data type offers are as follows:
===[Consistency][http://www.research.ibm.com/people/a/alpert/ptch/ptch.html]===
Many of Java’s ideas originate in C++ and in C++, objects and primitive type also co-exist. When object-oriented constructs were grafted onto the C language, C’s data types remained as is. The motivation behind this is that Bjarne Stroustrup, C++’s designer, wanted to be as consistent as possible with the base C language, hoping to capitalize on programmers’ pre-C++ knowledge.

===Simplicity===
It is simple and intuitive to use primitive data type in basic utility.

Example:

1. Recurring number in a loop.(C++)

for(int i=0;i<10;i++)

2. Temp variables that record only one or two data.

===Performance===

====Time====
Processing primitive data type operation would be faster than processing composite data type in most cases. There are several reasons result in this differences.
*Hardware processing discrepancy
Many primitive data operations (like integer addition) can be performed as a single machine instruction while processing of composite data type would be transformed to a combination of primitive data types. eg. Some processors offer specific instructions to process sequences of characters with a single instruction.

Example:

[http://www.research.ibm.com/people/a/alpert/ptch/ptch.html Difference in data fetching between primitive data and composite data in Java]

*Initialization overheads for composite data type
There are many initialization operations for composite data type. for example boxing and unboxing, constructors and destructors.
*Allocating and Garbage collection overhead for composite data type<ref>http://en.wikipedia.org/wiki/Garbage_collection_(computer_science)#Performance_implications garbage collection</ref><ref>http://www.ibm.com/developerworks/java/library/j-jtp01274/index.html Java theory and practice: Garbage collection and performance</ref>
Composite data type like class will have allocation and garbage collection overhead that may be beyond the control of the programmer and can sometimes lead to performance problems. For example, commonly used stop-the-world garbage collectors, which pause program execution at arbitrary times, may make garbage collection inappropriate for some [http://en.wikipedia.org/wiki/Embedded_system embedded systems], high-performance [http://en.wikipedia.org/wiki/Server_(computing) server] software, and applications with [http://en.wikipedia.org/wiki/Real-time_computing real-time] needs.In the early days of Java technology, allocating objects got a high overheads. There were lots of articles advising developers to avoid creating temporary objects unnecessarily because allocation (and the corresponding garbage-collection overhead) was expensive. Although the costs have been greatly reduced nowadays. It still much slower than primitive data type which don’t have such troubles.

Example:

public class Test{
double dur1,dur2;
int N=100000000;
public void test1()
{
int a=1,b=1;
long startTime1 = System.currentTimeMillis();
for(int i=0;i<N;i++){
a=a+b;
}
long endTime1 = System.currentTimeMillis();
System.out.println(endTime1-startTime1);
}
public void test2(){
Integer c=new Integer(1);
Integer d=new Integer(1);
long startTime2 = System.currentTimeMillis();
for(int i=0;i<N;i++){
c=c+d;
}
long endTime2 = System.currentTimeMillis();
System.out.println(endTime2-startTime2)
}

'''Average execution time for test1 is: 1 mm'''

'''Average execution time for test2 is: 702mm'''

'''(test case number: 1000 times )'''

====Space====
Composite data type will cost more memory space than primitive data type in general. The reason is not only for the overheads generated by constructors, destructors etc, but also the feature of data alignment. <ref>http://en.wikipedia.org/wiki/Data_structure_alignment#Data_structure_padding Data structure alignment</ref>

Example of data alignment （C++）
struct compose
{
char name;
int a;
int b;
}

We all know the size of char is 1 byte, the size of int is 4 bytes. But the size of the struct compose as shown above is 12 bytes but not 9 bytes.

====Functionality====
Discussion of advantages and disadvantages should concerned the functionality you want to implement. For example if you want to operate a serials of int number. The performance of array may be better than int. <ref>http://cs.smith.edu/~thiebaut/ArtOfAssembly/CH05/CH05-2.html composite datatypes</ref>

[[File:1w1.gif]]

To access an element of an array, you need a function that converts an array index into the address of the indexed element. For a single dimension array, this function is very simple. It is
Element_Address = Base_Address + ((Index - Initial_Index) * Element_Size)
However, If you use five primitive data type to implement the same function. It may cost more time for the cpu to search the address of each data.

== Conclusion ==

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T01:46:01Z

Yliu63: /* Advantages of primitives */

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T01:26:44Z

Yliu63: /* Space */

CSC/ECE 517 Fall 2012

2012-09-10T02:02:40Z

Yliu63:

*[[CSC/ECE 517 Fall 2012/ch1 n xx]]
*[[CSC/ECE 517 Fall 2012/ch1 1w1 rk]]
*[[CSC/ECE 517 Fall 2012/ch1 1w20 pp]]
*[[CSC/ECE 517 Fall 2012/ch1 1w6 pp]]
*[[CSC/ECE 517 Fall 2012/ch1 1w7 am]]
*[[CSC/ECE 517 Fall 2012/ch1 1w8 aa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w10 pk]]
*[[CSC/ECE 517 Fall 2012/ch1 1w14 gv]]
*[[CSC/ECE 517 Fall 2012/ch1 1w17 ir]]
*[[CSC/ECE 517 Fall 2012/ch1 1w22 an]]
*[[CSC/ECE 517 Fall 2012/ch1 1w21 aa]]

CSC/ECE 517 Fall 2012/ch1 1w17 ss

2012-09-10T02:02:27Z

Yliu63: Blanked the page

CSC/ECE 517 Fall 2012/ch1 1w17 ss

2012-09-10T01:21:12Z

Yliu63:

== '''Extending objects''' ==

CSC/ECE 517 Fall 2012/ch1 1w17 ss

2012-09-10T01:20:50Z

Yliu63: /* Extending objects */

'''

'''== Extending objects =='''

CSC/ECE 517 Fall 2012/ch1 1w17 ss

2012-09-10T01:20:29Z

Yliu63:

'''
== Extending objects ==
'''

CSC/ECE 517 Fall 2012/ch1 1w17 ss

2012-09-10T01:20:07Z

Yliu63: /* Extending objects */

'''== Extending objects =='''

CSC/ECE 517 Fall 2012/ch1 1w17 ss

2012-09-10T01:19:10Z

Yliu63: Created page with " == Extending objects =="

== Extending objects ==

CSC/ECE 517 Fall 2012

2012-09-10T01:18:36Z

Yliu63: