Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:47:12Z

Sren: /* Responsibility-driven design principles and constructs */

''Responsibility-Driven Design''
== Introduction ==
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming(OOP) language] enable software to be reusable, refinable, testable, maintainable, and extensible by supporting [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation]. In order to realize these advantages, encapsulation should be maximized during the design process. other techniques attempt to enforce encapsulation during the implementation phase. This is too late in the software life-cycle to achieve maximum benefits.

Responsibility-driven design(RRD) is an alternate design method to focus on increasing the encapsulation by viewing a program in terms of the client/server model.<ref>http://dl.acm.org/citation.cfm?doid=74877.74885 Object-oriented design: a responsibility-driven approach</ref> This method was proposed by [http://en.wikipedia.org/wiki/Rebecca_Wirfs-Brock Rebecca Wirfs-Brock] and Brian Wilkerson.

== Definition ==
RDD is defined as follows:

Responsibility-driven design is inspired by the [http://en.wikipedia.org/wiki/Client%E2%80%93server_model client/server model]. It focuses on the contract by asking:

* What actions is this object responsible for?
* What information does this object share?<ref>http://dl.acm.org/citation.cfm?doid=74877.74885 Object-oriented design: a responsibility-driven approach</ref>

== Responsibility-driven design principles and analysis==
=== Principles ===
* Maximize Abstraction

Initially hide the distinction between data and behavior.

Think of objects responsibilities for “knowing”, “doing”,and “deciding”.

* Distribute Behavior

Promote a delegated control architecture.

Make objects smart—-have them behave intelligently, not just hold bundles of data.

*Preserve Flexibility

Design objects so interior details can be readily changed.
=== Analysis ===
The analysis stage of RDD consists of three phases
*System Deﬁnition
High-level view of system
*Detailed Description
Detailed view of development process, functional requirements, and non-functional requirements.
*Object Analysis
Construction of domain objects。<ref>http://www.wirfs-brock.com/ RRD principles and constructs</ref>

== Example ==
== Advantages ==
*Increased encapsulation:
The responsibility-driven approach emphasizes the encapsulation of both the structure and behavior of objects by focusing on the contractual responsibilities of a class. l It improves encapsulation with respect to subclass clients, ensuring that all inherited behavior is part of the contract of the subclass. The benefit is increased encapsulation, since the specification of the exact way in which a request is carried out is private to the server. Encapsulation is compromised when the structural details of an object become part of the interface. Responsibility-driven designs maximize encapsulation by ignoring the structural details.
*Facilitates polymorphism:
By encouraging the designer to focus on responsibilities independently of implementation, the responsibility driven approach can help a designer identify standard protocols (message names), which facilitates polymorphism. It makes abstract classes easier to identify. One difficulty in identifying abstract classes lies in determining what parts of the protocol of existing classes are parts of the type of those classes, and what parts are implementation details. Because the protocol of a class includes only those messages which form the type of the class, this problem is eliminated.

== Comparison of Responsibility-driven design with Data-driven design ==

Adapting abstract data type design methods to object-oriented programming results in a data-driven design. On the other hand, Responsibility-driven design is in direct contrast with Data-driven design, which promotes defining the behavior of a class along the data that it holds.

'''''Why responsibility-driven design over data-driven design?'''''

While data-driven design does prevent coupling of data and functionality, in some cases, data-driven programming has been argued to lead to bad object-oriented design, especially when dealing with more abstract data. This is because a purely data-driven object or entity is defined by the way it is represented. Any attempt to change the structure of the object would immediately break the functions that rely on it. As a, perhaps trivial, example, one might represent driving directions as a series of intersections (two intersecting streets) where the driver must turn right or left. If an intersection (in the United States) is represented in data by the zip code (5-digit number) and two street names (strings of text), you might run into bugs when you discover a city where streets intersect multiple times. While this example may be over simplified, restructuring of data is fairly common problem in software engineering, either to eliminate bugs, increase efficiency, or support new features. In these cases responsibility-driven design may be promoted as a better approach, where functionality and data can be coupled together, so functions don't have to deal with the data representation itself.

== Conclusion ==
Responsibility-Driven Design is A way to design software that emphasizes modeling of objects’ roles, responsibilities, and collaborations. Its principle is to maximize abstraction, delegate control and preserve flexibility. RDD increased encapsulation by focusing on the contractual responsibilities of a class and it facilities polymorphism by encouraging the designer to focus on responsibilities independently of implementation.

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:36:33Z

Sren: /* Conclusion */

''Responsibility-Driven Design''
== Introduction ==
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming(OOP) language] enable software to be reusable, refinable, testable, maintainable, and extensible by supporting [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation]. In order to realize these advantages, encapsulation should be maximized during the design process. other techniques attempt to enforce encapsulation during the implementation phase. This is too late in the software life-cycle to achieve maximum benefits.

Responsibility-driven design(RRD) is an alternate design method to focus on increasing the encapsulation by viewing a program in terms of the client/server model.<ref>http://dl.acm.org/citation.cfm?doid=74877.74885 Object-oriented design: a responsibility-driven approach</ref> This method was proposed by [http://en.wikipedia.org/wiki/Rebecca_Wirfs-Brock Rebecca Wirfs-Brock] and Brian Wilkerson.

== Definition ==
RDD is defined as follows:

Responsibility-driven design is inspired by the [http://en.wikipedia.org/wiki/Client%E2%80%93server_model client/server model]. It focuses on the contract by asking:

* What actions is this object responsible for?
* What information does this object share?<ref>http://dl.acm.org/citation.cfm?doid=74877.74885 Object-oriented design: a responsibility-driven approach</ref>

== Responsibility-driven design principles and constructs==
=== Principles ===
* Maximize Abstraction

Initially hide the distinction between data and behavior.

Think of objects responsibilities for “knowing”, “doing”,and “deciding”.

* Distribute Behavior

Promote a delegated control architecture.

Make objects smart—-have them behave intelligently, not just hold bundles of data.

*Preserve Flexibility

Design objects so interior details can be readily changed.
=== Constructs===
*an application = a set of interacting objects
*an object = an implementation of one or more roles
*a role = a set of related responsibilities
*a responsibility = an obligation to perform a task or know information
*a collaboration = an interaction of objects or roles (or both)
*a contract = an agreement outlining the terms of a collaboration <ref>http://www.wirfs-brock.com/ RRD principles and constructs</ref>

== Example ==
== Advantages ==
*Increased encapsulation:
The responsibility-driven approach emphasizes the encapsulation of both the structure and behavior of objects by focusing on the contractual responsibilities of a class. l It improves encapsulation with respect to subclass clients, ensuring that all inherited behavior is part of the contract of the subclass. The benefit is increased encapsulation, since the specification of the exact way in which a request is carried out is private to the server. Encapsulation is compromised when the structural details of an object become part of the interface. Responsibility-driven designs maximize encapsulation by ignoring the structural details.
*Facilitates polymorphism:
By encouraging the designer to focus on responsibilities independently of implementation, the responsibility driven approach can help a designer identify standard protocols (message names), which facilitates polymorphism. It makes abstract classes easier to identify. One difficulty in identifying abstract classes lies in determining what parts of the protocol of existing classes are parts of the type of those classes, and what parts are implementation details. Because the protocol of a class includes only those messages which form the type of the class, this problem is eliminated.

== Comparison ==
== Conclusion ==
Responsibility-Driven Design is A way to design software that emphasizes modeling of objects’ roles, responsibilities, and collaborations. Its principle is to maximize abstraction, delegate control and preserve flexibility. RDD increased encapsulation by focusing on the contractual responsibilities of a class and it facilities polymorphism by encouraging the designer to focus on responsibilities independently of implementation.

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:36:22Z

Sren: /* Conclusion */

''Responsibility-Driven Design''
== Introduction ==
[http://en.wikipedia.org/wiki/Object-oriented_programming Object-oriented programming(OOP) language] enable software to be reusable, refinable, testable, maintainable, and extensible by supporting [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation]. In order to realize these advantages, encapsulation should be maximized during the design process. other techniques attempt to enforce encapsulation during the implementation phase. This is too late in the software life-cycle to achieve maximum benefits.

Responsibility-driven design(RRD) is an alternate design method to focus on increasing the encapsulation by viewing a program in terms of the client/server model.<ref>http://dl.acm.org/citation.cfm?doid=74877.74885 Object-oriented design: a responsibility-driven approach</ref> This method was proposed by [http://en.wikipedia.org/wiki/Rebecca_Wirfs-Brock Rebecca Wirfs-Brock] and Brian Wilkerson.

== Definition ==
RDD is defined as follows:

Responsibility-driven design is inspired by the [http://en.wikipedia.org/wiki/Client%E2%80%93server_model client/server model]. It focuses on the contract by asking:

* What actions is this object responsible for?
* What information does this object share?<ref>http://dl.acm.org/citation.cfm?doid=74877.74885 Object-oriented design: a responsibility-driven approach</ref>

== Responsibility-driven design principles and constructs==
=== Principles ===
* Maximize Abstraction

Initially hide the distinction between data and behavior.

Think of objects responsibilities for “knowing”, “doing”,and “deciding”.

* Distribute Behavior

Promote a delegated control architecture.

Make objects smart—-have them behave intelligently, not just hold bundles of data.

*Preserve Flexibility

Design objects so interior details can be readily changed.
=== Constructs===
*an application = a set of interacting objects
*an object = an implementation of one or more roles
*a role = a set of related responsibilities
*a responsibility = an obligation to perform a task or know information
*a collaboration = an interaction of objects or roles (or both)
*a contract = an agreement outlining the terms of a collaboration <ref>http://www.wirfs-brock.com/ RRD principles and constructs</ref>

== Example ==
== Advantages ==
*Increased encapsulation:
The responsibility-driven approach emphasizes the encapsulation of both the structure and behavior of objects by focusing on the contractual responsibilities of a class. l It improves encapsulation with respect to subclass clients, ensuring that all inherited behavior is part of the contract of the subclass. The benefit is increased encapsulation, since the specification of the exact way in which a request is carried out is private to the server. Encapsulation is compromised when the structural details of an object become part of the interface. Responsibility-driven designs maximize encapsulation by ignoring the structural details.
*Facilitates polymorphism:
By encouraging the designer to focus on responsibilities independently of implementation, the responsibility driven approach can help a designer identify standard protocols (message names), which facilitates polymorphism. It makes abstract classes easier to identify. One difficulty in identifying abstract classes lies in determining what parts of the protocol of existing classes are parts of the type of those classes, and what parts are implementation details. Because the protocol of a class includes only those messages which form the type of the class, this problem is eliminated.

== Comparison ==
== Conclusion ==
Conclusion:
Responsibility-Driven Design is A way to design software that emphasizes modeling of objects’ roles, responsibilities, and collaborations. Its principle is to maximize abstraction, delegate control and preserve flexibility. RDD increased encapsulation by focusing on the contractual responsibilities of a class and it facilities polymorphism by encouraging the designer to focus on responsibilities independently of implementation.

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:33:25Z

Sren: /* Definition */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:29:12Z

Sren: /* Advantages */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:27:28Z

Sren: /* Constructs */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:23:12Z

Sren: /* Advantages */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:22:53Z

Sren: /* Constructs */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:17:43Z

Sren:

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:15:14Z

Sren: /* Responsibility-driven design principles */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:12:55Z

Sren: /* Advantages */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:11:45Z

Sren:

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:10:33Z

Sren: /* Advantages */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:09:37Z

Sren: /* Definition */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:09:09Z

Sren: /* Definition */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:08:31Z

Sren: /* Client-server model */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:04:50Z

Sren:

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:04:31Z

Sren: /* Advantages */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-27T00:03:42Z

Sren: /* Responsibility-driven design principles */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-26T23:51:51Z

Sren:

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-26T23:49:28Z

Sren: /* Client-server model */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-26T23:29:17Z

Sren: /* Definition */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-26T23:28:44Z

Sren: /* Responsibility */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-26T23:23:46Z

Sren: /* Definition */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-26T23:23:24Z

Sren: /* Definition */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-26T23:22:09Z

Sren: /* Introduction */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-26T23:21:40Z

Sren: /* Introduction */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-26T23:21:29Z

Sren: /* Introduction */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-26T23:15:40Z

Sren: /* Introduction */

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-26T23:11:43Z

Sren:

''Responsibility-Driven Design''
== Introduction ==
== Definition ==
== Responsibility ==
== Advantages ==
== Disadvantages ==
== Comparison ==
== Conclusion ==
== References ==
<references/>

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-26T23:04:01Z

Sren:

''Responsibility-Driven Design''
== Introduction ==
== Responsibility ==
== Advantages ==
== Disadvantages ==
== Comparison ==
== Conclusion ==
== References ==
<references/>

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-26T23:03:25Z

Sren: /* conclusion */

''Responsibility-Driven Design''
==Introduction==
==Responsibility==
==Advantages==
==Disadvantages==
==Comparison==
==Conclusion==

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-26T23:02:43Z

Sren:

''Responsibility-Driven Design''
==Introduction==
==Responsibility==
==Advantages==
==Disadvantages==
==Comparison==
==conclusion==

CSC/ECE 517 Fall 2012/ch2a 2w23 sr

2012-10-21T03:21:28Z

Sren: Created page with "=Responsibility-Driven Design="

=Responsibility-Driven Design=

CSC/ECE 517 Fall 2012

2012-10-21T03:16:24Z

Sren:

*[[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 1w5 su]]
*[[CSC/ECE 517 Fall 2012/ch1 1w6 pp]]
*[[CSC/ECE 517 Fall 2012/ch1 1w4 aj]]
*[[CSC/ECE 517 Fall 2012/ch1 1w7 am]]
*[[CSC/ECE 517 Fall 2012/ch1 1w8 aa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w9 av]]
*[[CSC/ECE 517 Fall 2012/ch1 1w10 pk]]
*[[CSC/ECE 517 Fall 2012/ch1 1w11 ap]]
*[[CSC/ECE 517 Fall 2012/ch1a 1w12 mv]]
*[[CSC/ECE 517 Fall 2012/ch1 1w14 gv]]
*[[CSC/ECE 517 Fall 2012/ch1 1w17 ir]]
*[[CSC/ECE 517 Fall 2012/ch1 1w18 as]]
*[[CSC/ECE 517 Fall 2012/ch1 1w22 an]]
*[[CSC/ECE 517 Fall 2012/ch1 1w21 aa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w21 wi]]
*[[CSC/ECE 517 Fall 2012/ch1 1w31 sa]]
*[[CSC/ECE 517 Fall 2012/ch1a 1w16 br]]
*[[CSC/ECE 517 Fall 2012/ch1a 1w23 as]]
*[[CSC/ECE 517 Fall 2012/ch1 1w24 nr]]
*[[CSC/ECE 517 Fall 2012/ch1 1w15 rt]]
*[[CSC/ECE 517 Fall 2012/ch1 1w3 pl]]
*[[CSC/ECE 517 Fall 2012/ch1 1w32 cm]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w5 dp]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w37 ss]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w67 ks]]

*[[CSC/ECE 517 Fall 2012/ch1 1w27 ms]]
*[[CSC/ECE 517 Fall 2012/ch1 1w29 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w33 op]]
*[[CSC/ECE 517 Fall 2012/ch1 1w19 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w34 vd]]
*[[CSC/ECE 517 Fall 2012/ch1 1w35 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w30 rp]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w58 am]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w47 sk]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w69 mv]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w44 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w45 is]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w53 kc]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w40 ar]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w39 sn]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w54 go]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w56 ms]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w64 nn]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w66 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w40 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w42 js]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w46 sm]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w71 gs]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w63 dv]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w55 ms]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w57 mp]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w52 an]]
*[[CSC/ECE_517_Fall_2012/ch1b 1w38 nm]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w60 ac]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w62 rb]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w29 st]]
*[[CSC/ECE 517 Fall 2012/ch 2w30 an]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w17 pt]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w31 up]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w9 ms]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w19 is]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w5 dp]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w16 dp]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w8 vp]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w18 as]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w3 jm]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w23 sr]]

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T03:27:34Z

Sren: /* Not supporting utility methods */

'''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:27:05Z

Sren: /* Inability on handling large scale data */

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T03:26:41Z

Sren: /* Cannot be extended */

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T03:25:47Z

Sren: /* Space performance */

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T03:25:24Z

Sren: /* Time performance */

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T03:24:49Z

Sren: /* Time performance */

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T03:23:43Z

Sren: /* Conclusion */

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T03:23:20Z

Sren: /* Time performance */

'''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:22:10Z

Sren: /* Cannot be extended */

'''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-11T03:21:27Z

Sren: /* Inability on handling large scale data */

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T03:21:09Z

Sren: /* Not supporting utility methods */

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T03:20:46Z

Sren: /* Functionality */

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T03:17:02Z

Sren: /* Space performance */

'''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 ==

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T03:14:55Z

Sren: /* 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 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 ==

== References ==
<references/>

CSC/ECE 517 Fall 2012/ch1 1w21 wi

2012-09-11T03:02:08Z

Sren: /* 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 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 uncertainty of array</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 of primitive</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 utility function associated with non primitive data types</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 ==

== References ==
<references/>