Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-18T20:50:53Z

Agarg5: /* Env Dump and Session Dump */

==Introduction==
This is a wiki article for the material presented in the Coursera SaaS video series, [https://www.youtube.com/watch?v=Ee5vfe0mLb8 3.13 Debugging by Dr. Armando Fox and Dr. David Patterson]. We aim to cover all the material presented in the video with definitions and examples
===Why debugging in Rails can be tricky?===
*We are used to printing the error on the terminal in most applications(Example: [http://www.cplusplus.com/reference/clibrary/cstdio/stderr/ STDERR]). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.

*Errors early in flow might manifest itself late.
Consider the following hierarchy seen in a Rails application:
URI -> Route -> Controller -> Model -> View -> Renderer

Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.

*Errors can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging based on the mode of operation, that is development mode or production mode:

'''Printing to terminal:'''This is useful for developers, when they are writing code they can print errors to the terminal and then examine them. We cannot use this approach in production mode. 

'''Logging:''' This is a more general approach to debugging which can be used in both modes. The logged entries are permanent record of what the application is doing. The recorded errors are saved in a log file and can be referenced later. 

'''Interactive Debugging:''' Using this tool you can stop the application in its tracks and inspect the state of the variables or other parameters to locate the error. 

Here is a summary of the various approaches and the modes in which they can be used: 
{| class="wikitable"
|-
! Approach !! Development !! Production
|-
| Printing to Terminal || ✓ ||
|-
| Logging || ✓ || ✓
|-
| Interactive Debugging || ✓ ||
|}

==RASP==
Steps to follow when faced with an error can be concisely represented by RASP according to Dr. Fox.
===What is RASP?===
RASP is an acronym which briefs the steps which a developer could follow if she were facing an error message. It stands for:
#'''Read''' the error message.
#'''Ask''' your colleague
#'''Search''' using [http://stackoverflow.com/ Stack Overflow] or any other search engine.
#'''Post''' on [http://stackoverflow.com/ Stack Overflow] or class forum

Reading the error message carefully is the first step in debugging. The error messages in Rails are incredibly detailed and it gives us a lot of information, reading it carefully can help us locate the file and line in which you are facing the error. But what if the line looks alright to you? 
The next step is to ask a colleague an informed question. In case you are doing pair programming, this is a good step to take. The question has to be of the form "I am trying to do this and I expected to get this but I got this other thing instead of foo." 
If the previous steps fail then searching using stack overflow or Google is next, especially if its an error which is particular to a version of gems or OS. 
In case you don't find a solution to your problem the final step is to get minimal but complete information which reproduces the error message which you are experiencing and post it. 

Here is an example question and solution from stack overflow: 

[[File:Ques.png]] 
As we can see the question follows the guidelines explained above. It gives minimal but complete information about the error. It does not give the entire description of the error. It is important to post minimal information so that the person who answers the question can understand your problem quickly. 
[[File:Ans.png]] 
The answer is posted within an hour of posting the question. This shows that posting on stack overflow is a fast way of getting expert help with debugging.

==Understanding Error Messages in Rails==
Rails usually provides a very verbose description of error messages. Dr. Fox tells us that error messages are our friends, they try to not only show us what went wrong but a great deal of detail of where it went wrong. Let us look at an example error message. 

Example:
An error message was deliberately caused by entering a route which wouldn't work. The application which we are using is the backchannel application and we are trying to find a post with id=20 (it doesn't exist). This causes rails to throw the following error message.

<code>'''ActiveRecord::RecordNotFound in PostsController#show'''</code>

<code>Couldn't find Post with id=20 
Rails.root: C:/Users/BruceWayne/Downloads/BackChannelApplication 
Application Trace | Framework Trace | Full Trace </code>

'''What is the error message trying to tell us?''' 
It tells us that ActiveRecord raised the error, and the error was raised in the show method of the Posts Controller. Rails tried to find a post with id=20 but it failed.
===Application Trace===
The application trace will give us the file, line number and the method in which the error was thrown. For the above example the application trace will look like this: 
<code>app/controllers/posts_controller.rb:17:in `show'</code>

You can also get the application trace manually at any point through the following command:
begin
raise object.inspect
rescue
Rails.logger.warn $!.backtrace.to_yaml
end
This will cause a deliberate error along with an application trace of how you got there.

===Stack Trace===
Full stack trace shows us the entire stack trace of right when the application started until the problem is encountered. Usually stack traces are very lengthy but they can be very useful to solve problems. Here is a partial stack trace from the back channel application error which we saw before: 
<code>activerecord (3.2.8) lib/active_record/relation/finder_methods.rb:341:in `find_one' 
activerecord (3.2.8) lib/active_record/relation/finder_methods.rb:312:in `find_with_ids' 
activerecord (3.2.8) lib/active_record/relation/finder_methods.rb:107:in `find' 
C:in `find' 
app/controllers/posts_controller.rb:17:in `show' 
actionpack (3.2.8) lib/action_controller/metal/implicit_render.rb:4:in `send_action' 
actionpack (3.2.8) lib/abstract_controller/base.rb:167:in `process_action' </code>

We can see the stack trace right from where the Rails application started, we can see the calls to activerecord. It is unlikely that there would be a problem in those files. As we continue looking into the stack trace we see the find method, we can click on the link in the trace and it will take us to the line in which the error was found. Most often the first few lines of the stack trace will give us the cause behind the error.

Stack trace can be logged using the following lines of code:
begin
raise
rescue => e
logger.error e.message
e.backtrace.each { |line| logger.error line }
end

===Env Dump and Session Dump===
Session dump gives all the information of the user's session. This is useful if the error which needs to be fixed is particular to a user or a group of users.
<code>_csrf_token: "LiTiqHSVFOr8uT0+pFJhNCFjUc3YikuJy6F77QG+O1Y=" 
comment_id: 1 
post_id: 1 
session_id: "c562769a55b39620228ce6064aaa1637" 
user: #<User id: 4, name: "seriously", username: "seriously", email: "seriously@seriously.com", encrypted_password: "cb32e64bd4cb11c7424ea4ea75731450e99ed120d4bab155a42...", salt: "DlLGMQzwgU", is_admin: nil, created_at: "2012-11-18 01:08:35", updated_at: "2012-11-18 01:08:35"></code> 

A session dump can be obtained using the following command:
<%= debug session %>

Environment dump gives details of the rails runtime environment. If the error is localized to users who use the same version of a host or a protocol, we could find that out using the environment dump.
<code>GATEWAY_INTERFACE: "CGI/1.1" 
HTTP_ACCEPT: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" 
HTTP_ACCEPT_CHARSET: "ISO-8859-1,utf-8;q=0.7,*;q=0.3" 
HTTP_ACCEPT_ENCODING: "gzip,deflate,sdch" 
HTTP_ACCEPT_LANGUAGE: "en-US,en;q=0.8" 
REMOTE_ADDR: "127.0.0.1" 
REMOTE_HOST: "Wayne-PC" 
SERVER_NAME: "localhost" 
SERVER_PROTOCOL: "HTTP/1.1" </code>

===A Very Common Error Message in Ruby===
<code>undefined method ‘foo’ for nil:NilClass</code> 

Most often, it means that an assignment failed and we didn't check for errors. 
Example: <code>@m = Movie.find_by_id(id) #could be nil</code> 

When you try to call m.title after an assignment like the one above, it will throw this error.

==Rails Debugger==
===What is a debugger?===
Sometimes printing errors to the console or logging is not enough to find out the root cause behind an error message. It is during these times when the debugger is a developer's best friend. The debugger helps us to step forward or backward in the code, execute or skip lines of code, examine the state of a variable or a parameter which has been passed. This will help the developer pinpoint to the actual source of the problem and fix it. 

'''How to install the debugger?''' 
In Rails, ruby-debug is a gem. We can install it like any other gem. To use the gem in a Rails application we need to add the following line: 
<code>require "ruby-debug"</code> 
in the <code>config/environments/development.rb</code> file. 

In Ruby 1.9, you can use this command to install a compatible version of the debugger gem: 
<code>gem install debugger</code> 
'''Running the debugger '''
To use the debugger in the rails application we need to start the server with the <code>--debugger</code> option. 
<code>$ rails server --debugger</code>

If we don't do this we would encounter an error like this: 
<code>***** Debugger requested, but was not available: Start server with --debugger to enable *****</code> 

We can invoke the debugger from any method by using the <code>debugger</code> keyword in the method. 
Example: 

----

<code>class PostsController < ApplicationController
def new
debugger
@post = Post.new
end
end</code>

----
Once the debugger method is called a debugger shell is started inside the terminal window where the application server was launched, and the cursor will be placed at ruby-debug’s prompt <code>(rdb:n)</code> where n is the thread number. The prompt will show the next line of code which is waiting to run.

==Conclusion==
Rails is a relatively new platform for development, it is continually evolving which effectively means debugging is harder. However by leveraging the knowledge of people who have encountered similar errors before we can resolve a subset of the problems, the ones particular to versions of ruby and other gems. We have tools like debugger and application trace to help us solve problems which are specific to our application. To know more about using the debugger, please refer to the Further Reading section of the article.

==Further Reading==
# [http://guides.rubyonrails.org/debugging_rails_applications.html Rails Guide - Debugging Rails Applications]
# [http://www.sitepoint.com/debug-rails-app-ruby-debug/ Debug your rails app with ruby-debug]
# [http://rubyforge.org/projects/ruby-debug/ Ruby Forge - Documentation for ruby-debug]

==References==
# https://www.youtube.com/watch?v=Ee5vfe0mLb8
# http://railstips.org/blog/archives/2011/08/31/stupid-simple-debugging/
# http://guides.rubyonrails.org/debugging_rails_applications.html
# http://railscasts.com/episodes/54-debugging-with-ruby-debug
# http://bashdb.sourceforge.net/ruby-debug.html
# http://cheat.errtheblog.com/s/rdebug/
# http://railscasts.com/episodes/24-the-stack-trace
# http://www.scribd.com/doc/86869289/3/Rails-Cookery-3
# http://www.ruby-forum.com/topic/67687
# http://stackoverflow.com/questions/8408936/rake-dbmigrate-error

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-18T20:45:54Z

Agarg5: /* Stack Trace */

==Introduction==
This is a wiki article for the material presented in the Coursera SaaS video series, [https://www.youtube.com/watch?v=Ee5vfe0mLb8 3.13 Debugging by Dr. Armando Fox and Dr. David Patterson]. We aim to cover all the material presented in the video with definitions and examples
===Why debugging in Rails can be tricky?===
*We are used to printing the error on the terminal in most applications(Example: [http://www.cplusplus.com/reference/clibrary/cstdio/stderr/ STDERR]). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.

*Errors early in flow might manifest itself late.
Consider the following hierarchy seen in a Rails application:
URI -> Route -> Controller -> Model -> View -> Renderer

Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.

*Errors can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging based on the mode of operation, that is development mode or production mode:

'''Printing to terminal:'''This is useful for developers, when they are writing code they can print errors to the terminal and then examine them. We cannot use this approach in production mode. 

'''Logging:''' This is a more general approach to debugging which can be used in both modes. The logged entries are permanent record of what the application is doing. The recorded errors are saved in a log file and can be referenced later. 

'''Interactive Debugging:''' Using this tool you can stop the application in its tracks and inspect the state of the variables or other parameters to locate the error. 

Here is a summary of the various approaches and the modes in which they can be used: 
{| class="wikitable"
|-
! Approach !! Development !! Production
|-
| Printing to Terminal || ✓ ||
|-
| Logging || ✓ || ✓
|-
| Interactive Debugging || ✓ ||
|}

==RASP==
Steps to follow when faced with an error can be concisely represented by RASP according to Dr. Fox.
===What is RASP?===
RASP is an acronym which briefs the steps which a developer could follow if she were facing an error message. It stands for:
#'''Read''' the error message.
#'''Ask''' your colleague
#'''Search''' using [http://stackoverflow.com/ Stack Overflow] or any other search engine.
#'''Post''' on [http://stackoverflow.com/ Stack Overflow] or class forum

Reading the error message carefully is the first step in debugging. The error messages in Rails are incredibly detailed and it gives us a lot of information, reading it carefully can help us locate the file and line in which you are facing the error. But what if the line looks alright to you? 
The next step is to ask a colleague an informed question. In case you are doing pair programming, this is a good step to take. The question has to be of the form "I am trying to do this and I expected to get this but I got this other thing instead of foo." 
If the previous steps fail then searching using stack overflow or Google is next, especially if its an error which is particular to a version of gems or OS. 
In case you don't find a solution to your problem the final step is to get minimal but complete information which reproduces the error message which you are experiencing and post it. 

Here is an example question and solution from stack overflow: 

[[File:Ques.png]] 
As we can see the question follows the guidelines explained above. It gives minimal but complete information about the error. It does not give the entire description of the error. It is important to post minimal information so that the person who answers the question can understand your problem quickly. 
[[File:Ans.png]] 
The answer is posted within an hour of posting the question. This shows that posting on stack overflow is a fast way of getting expert help with debugging.

==Understanding Error Messages in Rails==
Rails usually provides a very verbose description of error messages. Dr. Fox tells us that error messages are our friends, they try to not only show us what went wrong but a great deal of detail of where it went wrong. Let us look at an example error message. 

Example:
An error message was deliberately caused by entering a route which wouldn't work. The application which we are using is the backchannel application and we are trying to find a post with id=20 (it doesn't exist). This causes rails to throw the following error message.

<code>'''ActiveRecord::RecordNotFound in PostsController#show'''</code>

<code>Couldn't find Post with id=20 
Rails.root: C:/Users/BruceWayne/Downloads/BackChannelApplication 
Application Trace | Framework Trace | Full Trace </code>

'''What is the error message trying to tell us?''' 
It tells us that ActiveRecord raised the error, and the error was raised in the show method of the Posts Controller. Rails tried to find a post with id=20 but it failed.
===Application Trace===
The application trace will give us the file, line number and the method in which the error was thrown. For the above example the application trace will look like this: 
<code>app/controllers/posts_controller.rb:17:in `show'</code>

You can also get the application trace manually at any point through the following command:
begin
raise object.inspect
rescue
Rails.logger.warn $!.backtrace.to_yaml
end
This will cause a deliberate error along with an application trace of how you got there.

===Stack Trace===
Full stack trace shows us the entire stack trace of right when the application started until the problem is encountered. Usually stack traces are very lengthy but they can be very useful to solve problems. Here is a partial stack trace from the back channel application error which we saw before: 
<code>activerecord (3.2.8) lib/active_record/relation/finder_methods.rb:341:in `find_one' 
activerecord (3.2.8) lib/active_record/relation/finder_methods.rb:312:in `find_with_ids' 
activerecord (3.2.8) lib/active_record/relation/finder_methods.rb:107:in `find' 
C:in `find' 
app/controllers/posts_controller.rb:17:in `show' 
actionpack (3.2.8) lib/action_controller/metal/implicit_render.rb:4:in `send_action' 
actionpack (3.2.8) lib/abstract_controller/base.rb:167:in `process_action' </code>

We can see the stack trace right from where the Rails application started, we can see the calls to activerecord. It is unlikely that there would be a problem in those files. As we continue looking into the stack trace we see the find method, we can click on the link in the trace and it will take us to the line in which the error was found. Most often the first few lines of the stack trace will give us the cause behind the error.

Stack trace can be logged using the following lines of code:
begin
raise
rescue => e
logger.error e.message
e.backtrace.each { |line| logger.error line }
end

===Env Dump and Session Dump===
Session dump gives all the information of the user's session. This is useful if the error which needs to be fixed is particular to a user or a group of users.
<code>_csrf_token: "LiTiqHSVFOr8uT0+pFJhNCFjUc3YikuJy6F77QG+O1Y=" 
comment_id: 1 
post_id: 1 
session_id: "c562769a55b39620228ce6064aaa1637" 
user: #<User id: 4, name: "seriously", username: "seriously", email: "seriously@seriously.com", encrypted_password: "cb32e64bd4cb11c7424ea4ea75731450e99ed120d4bab155a42...", salt: "DlLGMQzwgU", is_admin: nil, created_at: "2012-11-18 01:08:35", updated_at: "2012-11-18 01:08:35"></code> 

Environment dump gives details of the rails runtime environment. If the error is localized to users who use the same version of a host or a protocol, we could find that out using the environment dump.
<code>GATEWAY_INTERFACE: "CGI/1.1" 
HTTP_ACCEPT: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" 
HTTP_ACCEPT_CHARSET: "ISO-8859-1,utf-8;q=0.7,*;q=0.3" 
HTTP_ACCEPT_ENCODING: "gzip,deflate,sdch" 
HTTP_ACCEPT_LANGUAGE: "en-US,en;q=0.8" 
REMOTE_ADDR: "127.0.0.1" 
REMOTE_HOST: "Wayne-PC" 
SERVER_NAME: "localhost" 
SERVER_PROTOCOL: "HTTP/1.1" </code>

===A Very Common Error Message in Ruby===
<code>undefined method ‘foo’ for nil:NilClass</code> 

Most often, it means that an assignment failed and we didn't check for errors. 
Example: <code>@m = Movie.find_by_id(id) #could be nil</code> 

When you try to call m.title after an assignment like the one above, it will throw this error.

==Rails Debugger==
===What is a debugger?===
Sometimes printing errors to the console or logging is not enough to find out the root cause behind an error message. It is during these times when the debugger is a developer's best friend. The debugger helps us to step forward or backward in the code, execute or skip lines of code, examine the state of a variable or a parameter which has been passed. This will help the developer pinpoint to the actual source of the problem and fix it. 

'''How to install the debugger?''' 
In Rails, ruby-debug is a gem. We can install it like any other gem. To use the gem in a Rails application we need to add the following line: 
<code>require "ruby-debug"</code> 
in the <code>config/environments/development.rb</code> file. 

In Ruby 1.9, you can use this command to install a compatible version of the debugger gem: 
<code>gem install debugger</code> 
'''Running the debugger '''
To use the debugger in the rails application we need to start the server with the <code>--debugger</code> option. 
<code>$ rails server --debugger</code>

If we don't do this we would encounter an error like this: 
<code>***** Debugger requested, but was not available: Start server with --debugger to enable *****</code> 

We can invoke the debugger from any method by using the <code>debugger</code> keyword in the method. 
Example: 

----

<code>class PostsController < ApplicationController
def new
debugger
@post = Post.new
end
end</code>

----
Once the debugger method is called a debugger shell is started inside the terminal window where the application server was launched, and the cursor will be placed at ruby-debug’s prompt <code>(rdb:n)</code> where n is the thread number. The prompt will show the next line of code which is waiting to run.

==Conclusion==
Rails is a relatively new platform for development, it is continually evolving which effectively means debugging is harder. However by leveraging the knowledge of people who have encountered similar errors before we can resolve a subset of the problems, the ones particular to versions of ruby and other gems. We have tools like debugger and application trace to help us solve problems which are specific to our application. To know more about using the debugger, please refer to the Further Reading section of the article.

==Further Reading==
# [http://guides.rubyonrails.org/debugging_rails_applications.html Rails Guide - Debugging Rails Applications]
# [http://www.sitepoint.com/debug-rails-app-ruby-debug/ Debug your rails app with ruby-debug]
# [http://rubyforge.org/projects/ruby-debug/ Ruby Forge - Documentation for ruby-debug]

==References==
# https://www.youtube.com/watch?v=Ee5vfe0mLb8
# http://railstips.org/blog/archives/2011/08/31/stupid-simple-debugging/
# http://guides.rubyonrails.org/debugging_rails_applications.html
# http://railscasts.com/episodes/54-debugging-with-ruby-debug
# http://bashdb.sourceforge.net/ruby-debug.html
# http://cheat.errtheblog.com/s/rdebug/
# http://railscasts.com/episodes/24-the-stack-trace
# http://www.scribd.com/doc/86869289/3/Rails-Cookery-3
# http://www.ruby-forum.com/topic/67687
# http://stackoverflow.com/questions/8408936/rake-dbmigrate-error

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-18T20:43:36Z

Agarg5: /* Application Trace */

==Introduction==
This is a wiki article for the material presented in the Coursera SaaS video series, [https://www.youtube.com/watch?v=Ee5vfe0mLb8 3.13 Debugging by Dr. Armando Fox and Dr. David Patterson]. We aim to cover all the material presented in the video with definitions and examples
===Why debugging in Rails can be tricky?===
*We are used to printing the error on the terminal in most applications(Example: [http://www.cplusplus.com/reference/clibrary/cstdio/stderr/ STDERR]). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.

*Errors early in flow might manifest itself late.
Consider the following hierarchy seen in a Rails application:
URI -> Route -> Controller -> Model -> View -> Renderer

Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.

*Errors can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging based on the mode of operation, that is development mode or production mode:

'''Printing to terminal:'''This is useful for developers, when they are writing code they can print errors to the terminal and then examine them. We cannot use this approach in production mode. 

'''Logging:''' This is a more general approach to debugging which can be used in both modes. The logged entries are permanent record of what the application is doing. The recorded errors are saved in a log file and can be referenced later. 

'''Interactive Debugging:''' Using this tool you can stop the application in its tracks and inspect the state of the variables or other parameters to locate the error. 

Here is a summary of the various approaches and the modes in which they can be used: 
{| class="wikitable"
|-
! Approach !! Development !! Production
|-
| Printing to Terminal || ✓ ||
|-
| Logging || ✓ || ✓
|-
| Interactive Debugging || ✓ ||
|}

==RASP==
Steps to follow when faced with an error can be concisely represented by RASP according to Dr. Fox.
===What is RASP?===
RASP is an acronym which briefs the steps which a developer could follow if she were facing an error message. It stands for:
#'''Read''' the error message.
#'''Ask''' your colleague
#'''Search''' using [http://stackoverflow.com/ Stack Overflow] or any other search engine.
#'''Post''' on [http://stackoverflow.com/ Stack Overflow] or class forum

Reading the error message carefully is the first step in debugging. The error messages in Rails are incredibly detailed and it gives us a lot of information, reading it carefully can help us locate the file and line in which you are facing the error. But what if the line looks alright to you? 
The next step is to ask a colleague an informed question. In case you are doing pair programming, this is a good step to take. The question has to be of the form "I am trying to do this and I expected to get this but I got this other thing instead of foo." 
If the previous steps fail then searching using stack overflow or Google is next, especially if its an error which is particular to a version of gems or OS. 
In case you don't find a solution to your problem the final step is to get minimal but complete information which reproduces the error message which you are experiencing and post it. 

Here is an example question and solution from stack overflow: 

[[File:Ques.png]] 
As we can see the question follows the guidelines explained above. It gives minimal but complete information about the error. It does not give the entire description of the error. It is important to post minimal information so that the person who answers the question can understand your problem quickly. 
[[File:Ans.png]] 
The answer is posted within an hour of posting the question. This shows that posting on stack overflow is a fast way of getting expert help with debugging.

==Understanding Error Messages in Rails==
Rails usually provides a very verbose description of error messages. Dr. Fox tells us that error messages are our friends, they try to not only show us what went wrong but a great deal of detail of where it went wrong. Let us look at an example error message. 

Example:
An error message was deliberately caused by entering a route which wouldn't work. The application which we are using is the backchannel application and we are trying to find a post with id=20 (it doesn't exist). This causes rails to throw the following error message.

<code>'''ActiveRecord::RecordNotFound in PostsController#show'''</code>

<code>Couldn't find Post with id=20 
Rails.root: C:/Users/BruceWayne/Downloads/BackChannelApplication 
Application Trace | Framework Trace | Full Trace </code>

'''What is the error message trying to tell us?''' 
It tells us that ActiveRecord raised the error, and the error was raised in the show method of the Posts Controller. Rails tried to find a post with id=20 but it failed.
===Application Trace===
The application trace will give us the file, line number and the method in which the error was thrown. For the above example the application trace will look like this: 
<code>app/controllers/posts_controller.rb:17:in `show'</code>

You can also get the application trace manually at any point through the following command:
begin
raise object.inspect
rescue
Rails.logger.warn $!.backtrace.to_yaml
end
This will cause a deliberate error along with an application trace of how you got there.

===Stack Trace===
Full stack trace shows us the entire stack trace of right when the application started until the problem is encountered. Usually stack traces are very lengthy but they can be very useful to solve problems. Here is a partial stack trace from the back channel application error which we saw before: 
<code>activerecord (3.2.8) lib/active_record/relation/finder_methods.rb:341:in `find_one' 
activerecord (3.2.8) lib/active_record/relation/finder_methods.rb:312:in `find_with_ids' 
activerecord (3.2.8) lib/active_record/relation/finder_methods.rb:107:in `find' 
C:in `find' 
app/controllers/posts_controller.rb:17:in `show' 
actionpack (3.2.8) lib/action_controller/metal/implicit_render.rb:4:in `send_action' 
actionpack (3.2.8) lib/abstract_controller/base.rb:167:in `process_action' </code>

We can see the stack trace right from where the Rails application started, we can see the calls to activerecord. It is unlikely that there would be a problem in those files. As we continue looking into the stack trace we see the find method, we can click on the link in the trace and it will take us to the line in which the error was found. Most often the first few lines of the stack trace will give us the cause behind the error.
===Env Dump and Session Dump===
Session dump gives all the information of the user's session. This is useful if the error which needs to be fixed is particular to a user or a group of users.
<code>_csrf_token: "LiTiqHSVFOr8uT0+pFJhNCFjUc3YikuJy6F77QG+O1Y=" 
comment_id: 1 
post_id: 1 
session_id: "c562769a55b39620228ce6064aaa1637" 
user: #<User id: 4, name: "seriously", username: "seriously", email: "seriously@seriously.com", encrypted_password: "cb32e64bd4cb11c7424ea4ea75731450e99ed120d4bab155a42...", salt: "DlLGMQzwgU", is_admin: nil, created_at: "2012-11-18 01:08:35", updated_at: "2012-11-18 01:08:35"></code> 

Environment dump gives details of the rails runtime environment. If the error is localized to users who use the same version of a host or a protocol, we could find that out using the environment dump.
<code>GATEWAY_INTERFACE: "CGI/1.1" 
HTTP_ACCEPT: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" 
HTTP_ACCEPT_CHARSET: "ISO-8859-1,utf-8;q=0.7,*;q=0.3" 
HTTP_ACCEPT_ENCODING: "gzip,deflate,sdch" 
HTTP_ACCEPT_LANGUAGE: "en-US,en;q=0.8" 
REMOTE_ADDR: "127.0.0.1" 
REMOTE_HOST: "Wayne-PC" 
SERVER_NAME: "localhost" 
SERVER_PROTOCOL: "HTTP/1.1" </code>

===A Very Common Error Message in Ruby===
<code>undefined method ‘foo’ for nil:NilClass</code> 

Most often, it means that an assignment failed and we didn't check for errors. 
Example: <code>@m = Movie.find_by_id(id) #could be nil</code> 

When you try to call m.title after an assignment like the one above, it will throw this error.

==Rails Debugger==
===What is a debugger?===
Sometimes printing errors to the console or logging is not enough to find out the root cause behind an error message. It is during these times when the debugger is a developer's best friend. The debugger helps us to step forward or backward in the code, execute or skip lines of code, examine the state of a variable or a parameter which has been passed. This will help the developer pinpoint to the actual source of the problem and fix it. 

'''How to install the debugger?''' 
In Rails, ruby-debug is a gem. We can install it like any other gem. To use the gem in a Rails application we need to add the following line: 
<code>require "ruby-debug"</code> 
in the <code>config/environments/development.rb</code> file. 

In Ruby 1.9, you can use this command to install a compatible version of the debugger gem: 
<code>gem install debugger</code> 
'''Running the debugger '''
To use the debugger in the rails application we need to start the server with the <code>--debugger</code> option. 
<code>$ rails server --debugger</code>

If we don't do this we would encounter an error like this: 
<code>***** Debugger requested, but was not available: Start server with --debugger to enable *****</code> 

We can invoke the debugger from any method by using the <code>debugger</code> keyword in the method. 
Example: 

----

<code>class PostsController < ApplicationController
def new
debugger
@post = Post.new
end
end</code>

----
Once the debugger method is called a debugger shell is started inside the terminal window where the application server was launched, and the cursor will be placed at ruby-debug’s prompt <code>(rdb:n)</code> where n is the thread number. The prompt will show the next line of code which is waiting to run.

==Conclusion==
Rails is a relatively new platform for development, it is continually evolving which effectively means debugging is harder. However by leveraging the knowledge of people who have encountered similar errors before we can resolve a subset of the problems, the ones particular to versions of ruby and other gems. We have tools like debugger and application trace to help us solve problems which are specific to our application. To know more about using the debugger, please refer to the Further Reading section of the article.

==Further Reading==
# [http://guides.rubyonrails.org/debugging_rails_applications.html Rails Guide - Debugging Rails Applications]
# [http://www.sitepoint.com/debug-rails-app-ruby-debug/ Debug your rails app with ruby-debug]
# [http://rubyforge.org/projects/ruby-debug/ Ruby Forge - Documentation for ruby-debug]

==References==
# https://www.youtube.com/watch?v=Ee5vfe0mLb8
# http://railstips.org/blog/archives/2011/08/31/stupid-simple-debugging/
# http://guides.rubyonrails.org/debugging_rails_applications.html
# http://railscasts.com/episodes/54-debugging-with-ruby-debug
# http://bashdb.sourceforge.net/ruby-debug.html
# http://cheat.errtheblog.com/s/rdebug/
# http://railscasts.com/episodes/24-the-stack-trace
# http://www.scribd.com/doc/86869289/3/Rails-Cookery-3
# http://www.ruby-forum.com/topic/67687
# http://stackoverflow.com/questions/8408936/rake-dbmigrate-error

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-18T20:43:06Z

Agarg5: /* Application Trace */

==Introduction==
This is a wiki article for the material presented in the Coursera SaaS video series, [https://www.youtube.com/watch?v=Ee5vfe0mLb8 3.13 Debugging by Dr. Armando Fox and Dr. David Patterson]. We aim to cover all the material presented in the video with definitions and examples
===Why debugging in Rails can be tricky?===
*We are used to printing the error on the terminal in most applications(Example: [http://www.cplusplus.com/reference/clibrary/cstdio/stderr/ STDERR]). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.

*Errors early in flow might manifest itself late.
Consider the following hierarchy seen in a Rails application:
URI -> Route -> Controller -> Model -> View -> Renderer

Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.

*Errors can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging based on the mode of operation, that is development mode or production mode:

'''Printing to terminal:'''This is useful for developers, when they are writing code they can print errors to the terminal and then examine them. We cannot use this approach in production mode. 

'''Logging:''' This is a more general approach to debugging which can be used in both modes. The logged entries are permanent record of what the application is doing. The recorded errors are saved in a log file and can be referenced later. 

'''Interactive Debugging:''' Using this tool you can stop the application in its tracks and inspect the state of the variables or other parameters to locate the error. 

Here is a summary of the various approaches and the modes in which they can be used: 
{| class="wikitable"
|-
! Approach !! Development !! Production
|-
| Printing to Terminal || ✓ ||
|-
| Logging || ✓ || ✓
|-
| Interactive Debugging || ✓ ||
|}

==RASP==
Steps to follow when faced with an error can be concisely represented by RASP according to Dr. Fox.
===What is RASP?===
RASP is an acronym which briefs the steps which a developer could follow if she were facing an error message. It stands for:
#'''Read''' the error message.
#'''Ask''' your colleague
#'''Search''' using [http://stackoverflow.com/ Stack Overflow] or any other search engine.
#'''Post''' on [http://stackoverflow.com/ Stack Overflow] or class forum

Reading the error message carefully is the first step in debugging. The error messages in Rails are incredibly detailed and it gives us a lot of information, reading it carefully can help us locate the file and line in which you are facing the error. But what if the line looks alright to you? 
The next step is to ask a colleague an informed question. In case you are doing pair programming, this is a good step to take. The question has to be of the form "I am trying to do this and I expected to get this but I got this other thing instead of foo." 
If the previous steps fail then searching using stack overflow or Google is next, especially if its an error which is particular to a version of gems or OS. 
In case you don't find a solution to your problem the final step is to get minimal but complete information which reproduces the error message which you are experiencing and post it. 

Here is an example question and solution from stack overflow: 

[[File:Ques.png]] 
As we can see the question follows the guidelines explained above. It gives minimal but complete information about the error. It does not give the entire description of the error. It is important to post minimal information so that the person who answers the question can understand your problem quickly. 
[[File:Ans.png]] 
The answer is posted within an hour of posting the question. This shows that posting on stack overflow is a fast way of getting expert help with debugging.

==Understanding Error Messages in Rails==
Rails usually provides a very verbose description of error messages. Dr. Fox tells us that error messages are our friends, they try to not only show us what went wrong but a great deal of detail of where it went wrong. Let us look at an example error message. 

Example:
An error message was deliberately caused by entering a route which wouldn't work. The application which we are using is the backchannel application and we are trying to find a post with id=20 (it doesn't exist). This causes rails to throw the following error message.

<code>'''ActiveRecord::RecordNotFound in PostsController#show'''</code>

<code>Couldn't find Post with id=20 
Rails.root: C:/Users/BruceWayne/Downloads/BackChannelApplication 
Application Trace | Framework Trace | Full Trace </code>

'''What is the error message trying to tell us?''' 
It tells us that ActiveRecord raised the error, and the error was raised in the show method of the Posts Controller. Rails tried to find a post with id=20 but it failed.
===Application Trace===
The application trace will give us the file, line number and the method in which the error was thrown. For the above example the application trace will look like this: 
<code>app/controllers/posts_controller.rb:17:in `show'</code>

You can also get the application trace manually at any point through the following command:
begin
raise object.inspect
rescue
Rails.logger.warn $!.backtrace.to_yaml
end
This will cause a deliberate error along with an application trace of how you got there.

===Stack Trace===
Full stack trace shows us the entire stack trace of right when the application started until the problem is encountered. Usually stack traces are very lengthy but they can be very useful to solve problems. Here is a partial stack trace from the back channel application error which we saw before: 
<code>activerecord (3.2.8) lib/active_record/relation/finder_methods.rb:341:in `find_one' 
activerecord (3.2.8) lib/active_record/relation/finder_methods.rb:312:in `find_with_ids' 
activerecord (3.2.8) lib/active_record/relation/finder_methods.rb:107:in `find' 
C:in `find' 
app/controllers/posts_controller.rb:17:in `show' 
actionpack (3.2.8) lib/action_controller/metal/implicit_render.rb:4:in `send_action' 
actionpack (3.2.8) lib/abstract_controller/base.rb:167:in `process_action' </code>

We can see the stack trace right from where the Rails application started, we can see the calls to activerecord. It is unlikely that there would be a problem in those files. As we continue looking into the stack trace we see the find method, we can click on the link in the trace and it will take us to the line in which the error was found. Most often the first few lines of the stack trace will give us the cause behind the error.
===Env Dump and Session Dump===
Session dump gives all the information of the user's session. This is useful if the error which needs to be fixed is particular to a user or a group of users.
<code>_csrf_token: "LiTiqHSVFOr8uT0+pFJhNCFjUc3YikuJy6F77QG+O1Y=" 
comment_id: 1 
post_id: 1 
session_id: "c562769a55b39620228ce6064aaa1637" 
user: #<User id: 4, name: "seriously", username: "seriously", email: "seriously@seriously.com", encrypted_password: "cb32e64bd4cb11c7424ea4ea75731450e99ed120d4bab155a42...", salt: "DlLGMQzwgU", is_admin: nil, created_at: "2012-11-18 01:08:35", updated_at: "2012-11-18 01:08:35"></code> 

Environment dump gives details of the rails runtime environment. If the error is localized to users who use the same version of a host or a protocol, we could find that out using the environment dump.
<code>GATEWAY_INTERFACE: "CGI/1.1" 
HTTP_ACCEPT: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" 
HTTP_ACCEPT_CHARSET: "ISO-8859-1,utf-8;q=0.7,*;q=0.3" 
HTTP_ACCEPT_ENCODING: "gzip,deflate,sdch" 
HTTP_ACCEPT_LANGUAGE: "en-US,en;q=0.8" 
REMOTE_ADDR: "127.0.0.1" 
REMOTE_HOST: "Wayne-PC" 
SERVER_NAME: "localhost" 
SERVER_PROTOCOL: "HTTP/1.1" </code>

===A Very Common Error Message in Ruby===
<code>undefined method ‘foo’ for nil:NilClass</code> 

Most often, it means that an assignment failed and we didn't check for errors. 
Example: <code>@m = Movie.find_by_id(id) #could be nil</code> 

When you try to call m.title after an assignment like the one above, it will throw this error.

==Rails Debugger==
===What is a debugger?===
Sometimes printing errors to the console or logging is not enough to find out the root cause behind an error message. It is during these times when the debugger is a developer's best friend. The debugger helps us to step forward or backward in the code, execute or skip lines of code, examine the state of a variable or a parameter which has been passed. This will help the developer pinpoint to the actual source of the problem and fix it. 

'''How to install the debugger?''' 
In Rails, ruby-debug is a gem. We can install it like any other gem. To use the gem in a Rails application we need to add the following line: 
<code>require "ruby-debug"</code> 
in the <code>config/environments/development.rb</code> file. 

In Ruby 1.9, you can use this command to install a compatible version of the debugger gem: 
<code>gem install debugger</code> 
'''Running the debugger '''
To use the debugger in the rails application we need to start the server with the <code>--debugger</code> option. 
<code>$ rails server --debugger</code>

If we don't do this we would encounter an error like this: 
<code>***** Debugger requested, but was not available: Start server with --debugger to enable *****</code> 

We can invoke the debugger from any method by using the <code>debugger</code> keyword in the method. 
Example: 

----

<code>class PostsController < ApplicationController
def new
debugger
@post = Post.new
end
end</code>

----
Once the debugger method is called a debugger shell is started inside the terminal window where the application server was launched, and the cursor will be placed at ruby-debug’s prompt <code>(rdb:n)</code> where n is the thread number. The prompt will show the next line of code which is waiting to run.

==Conclusion==
Rails is a relatively new platform for development, it is continually evolving which effectively means debugging is harder. However by leveraging the knowledge of people who have encountered similar errors before we can resolve a subset of the problems, the ones particular to versions of ruby and other gems. We have tools like debugger and application trace to help us solve problems which are specific to our application. To know more about using the debugger, please refer to the Further Reading section of the article.

==Further Reading==
# [http://guides.rubyonrails.org/debugging_rails_applications.html Rails Guide - Debugging Rails Applications]
# [http://www.sitepoint.com/debug-rails-app-ruby-debug/ Debug your rails app with ruby-debug]
# [http://rubyforge.org/projects/ruby-debug/ Ruby Forge - Documentation for ruby-debug]

==References==
# https://www.youtube.com/watch?v=Ee5vfe0mLb8
# http://railstips.org/blog/archives/2011/08/31/stupid-simple-debugging/
# http://guides.rubyonrails.org/debugging_rails_applications.html
# http://railscasts.com/episodes/54-debugging-with-ruby-debug
# http://bashdb.sourceforge.net/ruby-debug.html
# http://cheat.errtheblog.com/s/rdebug/
# http://railscasts.com/episodes/24-the-stack-trace
# http://www.scribd.com/doc/86869289/3/Rails-Cookery-3
# http://www.ruby-forum.com/topic/67687
# http://stackoverflow.com/questions/8408936/rake-dbmigrate-error

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-18T20:38:48Z

Agarg5: /* Application Trace */

==Introduction==
This is a wiki article for the material presented in the Coursera SaaS video series, [https://www.youtube.com/watch?v=Ee5vfe0mLb8 3.13 Debugging by Dr. Armando Fox and Dr. David Patterson]. We aim to cover all the material presented in the video with definitions and examples
===Why debugging in Rails can be tricky?===
*We are used to printing the error on the terminal in most applications(Example: [http://www.cplusplus.com/reference/clibrary/cstdio/stderr/ STDERR]). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.

*Errors early in flow might manifest itself late.
Consider the following hierarchy seen in a Rails application:
URI -> Route -> Controller -> Model -> View -> Renderer

Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.

*Errors can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging based on the mode of operation, that is development mode or production mode:

'''Printing to terminal:'''This is useful for developers, when they are writing code they can print errors to the terminal and then examine them. We cannot use this approach in production mode. 

'''Logging:''' This is a more general approach to debugging which can be used in both modes. The logged entries are permanent record of what the application is doing. The recorded errors are saved in a log file and can be referenced later. 

'''Interactive Debugging:''' Using this tool you can stop the application in its tracks and inspect the state of the variables or other parameters to locate the error. 

Here is a summary of the various approaches and the modes in which they can be used: 
{| class="wikitable"
|-
! Approach !! Development !! Production
|-
| Printing to Terminal || ✓ ||
|-
| Logging || ✓ || ✓
|-
| Interactive Debugging || ✓ ||
|}

==RASP==
Steps to follow when faced with an error can be concisely represented by RASP according to Dr. Fox.
===What is RASP?===
RASP is an acronym which briefs the steps which a developer could follow if she were facing an error message. It stands for:
#'''Read''' the error message.
#'''Ask''' your colleague
#'''Search''' using [http://stackoverflow.com/ Stack Overflow] or any other search engine.
#'''Post''' on [http://stackoverflow.com/ Stack Overflow] or class forum

Reading the error message carefully is the first step in debugging. The error messages in Rails are incredibly detailed and it gives us a lot of information, reading it carefully can help us locate the file and line in which you are facing the error. But what if the line looks alright to you? 
The next step is to ask a colleague an informed question. In case you are doing pair programming, this is a good step to take. The question has to be of the form "I am trying to do this and I expected to get this but I got this other thing instead of foo." 
If the previous steps fail then searching using stack overflow or Google is next, especially if its an error which is particular to a version of gems or OS. 
In case you don't find a solution to your problem the final step is to get minimal but complete information which reproduces the error message which you are experiencing and post it. 

Here is an example question and solution from stack overflow: 

[[File:Ques.png]] 
As we can see the question follows the guidelines explained above. It gives minimal but complete information about the error. It does not give the entire description of the error. It is important to post minimal information so that the person who answers the question can understand your problem quickly. 
[[File:Ans.png]] 
The answer is posted within an hour of posting the question. This shows that posting on stack overflow is a fast way of getting expert help with debugging.

==Understanding Error Messages in Rails==
Rails usually provides a very verbose description of error messages. Dr. Fox tells us that error messages are our friends, they try to not only show us what went wrong but a great deal of detail of where it went wrong. Let us look at an example error message. 

Example:
An error message was deliberately caused by entering a route which wouldn't work. The application which we are using is the backchannel application and we are trying to find a post with id=20 (it doesn't exist). This causes rails to throw the following error message.

<code>'''ActiveRecord::RecordNotFound in PostsController#show'''</code>

<code>Couldn't find Post with id=20 
Rails.root: C:/Users/BruceWayne/Downloads/BackChannelApplication 
Application Trace | Framework Trace | Full Trace </code>

'''What is the error message trying to tell us?''' 
It tells us that ActiveRecord raised the error, and the error was raised in the show method of the Posts Controller. Rails tried to find a post with id=20 but it failed.
===Application Trace===
The application trace will give us the file, line number and the method in which the error was thrown. For the above example the application trace will look like this: 
<code>app/controllers/posts_controller.rb:17:in `show'</code>

You can also get the application trace manually at any point through the following command:
raise object.inspect
This will cause a deliberate error along with an application trace of how you got there.

===Stack Trace===
Full stack trace shows us the entire stack trace of right when the application started until the problem is encountered. Usually stack traces are very lengthy but they can be very useful to solve problems. Here is a partial stack trace from the back channel application error which we saw before: 
<code>activerecord (3.2.8) lib/active_record/relation/finder_methods.rb:341:in `find_one' 
activerecord (3.2.8) lib/active_record/relation/finder_methods.rb:312:in `find_with_ids' 
activerecord (3.2.8) lib/active_record/relation/finder_methods.rb:107:in `find' 
C:in `find' 
app/controllers/posts_controller.rb:17:in `show' 
actionpack (3.2.8) lib/action_controller/metal/implicit_render.rb:4:in `send_action' 
actionpack (3.2.8) lib/abstract_controller/base.rb:167:in `process_action' </code>

We can see the stack trace right from where the Rails application started, we can see the calls to activerecord. It is unlikely that there would be a problem in those files. As we continue looking into the stack trace we see the find method, we can click on the link in the trace and it will take us to the line in which the error was found. Most often the first few lines of the stack trace will give us the cause behind the error.
===Env Dump and Session Dump===
Session dump gives all the information of the user's session. This is useful if the error which needs to be fixed is particular to a user or a group of users.
<code>_csrf_token: "LiTiqHSVFOr8uT0+pFJhNCFjUc3YikuJy6F77QG+O1Y=" 
comment_id: 1 
post_id: 1 
session_id: "c562769a55b39620228ce6064aaa1637" 
user: #<User id: 4, name: "seriously", username: "seriously", email: "seriously@seriously.com", encrypted_password: "cb32e64bd4cb11c7424ea4ea75731450e99ed120d4bab155a42...", salt: "DlLGMQzwgU", is_admin: nil, created_at: "2012-11-18 01:08:35", updated_at: "2012-11-18 01:08:35"></code> 

Environment dump gives details of the rails runtime environment. If the error is localized to users who use the same version of a host or a protocol, we could find that out using the environment dump.
<code>GATEWAY_INTERFACE: "CGI/1.1" 
HTTP_ACCEPT: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" 
HTTP_ACCEPT_CHARSET: "ISO-8859-1,utf-8;q=0.7,*;q=0.3" 
HTTP_ACCEPT_ENCODING: "gzip,deflate,sdch" 
HTTP_ACCEPT_LANGUAGE: "en-US,en;q=0.8" 
REMOTE_ADDR: "127.0.0.1" 
REMOTE_HOST: "Wayne-PC" 
SERVER_NAME: "localhost" 
SERVER_PROTOCOL: "HTTP/1.1" </code>

===A Very Common Error Message in Ruby===
<code>undefined method ‘foo’ for nil:NilClass</code> 

Most often, it means that an assignment failed and we didn't check for errors. 
Example: <code>@m = Movie.find_by_id(id) #could be nil</code> 

When you try to call m.title after an assignment like the one above, it will throw this error.

==Rails Debugger==
===What is a debugger?===
Sometimes printing errors to the console or logging is not enough to find out the root cause behind an error message. It is during these times when the debugger is a developer's best friend. The debugger helps us to step forward or backward in the code, execute or skip lines of code, examine the state of a variable or a parameter which has been passed. This will help the developer pinpoint to the actual source of the problem and fix it. 

'''How to install the debugger?''' 
In Rails, ruby-debug is a gem. We can install it like any other gem. To use the gem in a Rails application we need to add the following line: 
<code>require "ruby-debug"</code> 
in the <code>config/environments/development.rb</code> file. 

In Ruby 1.9, you can use this command to install a compatible version of the debugger gem: 
<code>gem install debugger</code> 
'''Running the debugger '''
To use the debugger in the rails application we need to start the server with the <code>--debugger</code> option. 
<code>$ rails server --debugger</code>

If we don't do this we would encounter an error like this: 
<code>***** Debugger requested, but was not available: Start server with --debugger to enable *****</code> 

We can invoke the debugger from any method by using the <code>debugger</code> keyword in the method. 
Example: 

----

<code>class PostsController < ApplicationController
def new
debugger
@post = Post.new
end
end</code>

----
Once the debugger method is called a debugger shell is started inside the terminal window where the application server was launched, and the cursor will be placed at ruby-debug’s prompt <code>(rdb:n)</code> where n is the thread number. The prompt will show the next line of code which is waiting to run.

==Conclusion==
Rails is a relatively new platform for development, it is continually evolving which effectively means debugging is harder. However by leveraging the knowledge of people who have encountered similar errors before we can resolve a subset of the problems, the ones particular to versions of ruby and other gems. We have tools like debugger and application trace to help us solve problems which are specific to our application. To know more about using the debugger, please refer to the Further Reading section of the article.

==Further Reading==
# [http://guides.rubyonrails.org/debugging_rails_applications.html Rails Guide - Debugging Rails Applications]
# [http://www.sitepoint.com/debug-rails-app-ruby-debug/ Debug your rails app with ruby-debug]
# [http://rubyforge.org/projects/ruby-debug/ Ruby Forge - Documentation for ruby-debug]

==References==
# https://www.youtube.com/watch?v=Ee5vfe0mLb8
# http://railstips.org/blog/archives/2011/08/31/stupid-simple-debugging/
# http://guides.rubyonrails.org/debugging_rails_applications.html
# http://railscasts.com/episodes/54-debugging-with-ruby-debug
# http://bashdb.sourceforge.net/ruby-debug.html
# http://cheat.errtheblog.com/s/rdebug/
# http://railscasts.com/episodes/24-the-stack-trace
# http://www.scribd.com/doc/86869289/3/Rails-Cookery-3
# http://www.ruby-forum.com/topic/67687
# http://stackoverflow.com/questions/8408936/rake-dbmigrate-error

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-17T04:49:33Z

Agarg5: /* References */

==Introduction==
===Debugging in SaaS/Rails can be tricky===
1) Some people are used to printing the error on the terminal(ex. Standard error). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.

2)Errors early in flow might manifest itself late.
For example,
Consider the following hierarchy:
URI -> Route -> Controller -> model -> view -> renderer
Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.
3) Error can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging on Saas depending on the mode of operation.

===Printing to terminal===
In development mode the user is the master and he can easily debug using this approach. This is not possible in production mode though.

===Logging===
This is a more general approach. The logged entries are permanent record of what your application is doing. The recorded errors can also be used to be referenced later. This approach can be used both in the development mode as well as the production mode.

===Interactive Debugging===
In this approach you can stop the application in its track and inspect the variables or other parameters to locate the error.

==RASP==

===Tips to deal with an error===
i) Read the error message carefully.

ii) Ask your colleague an informed question in case you are doing pair programming.

iii) Search using StackOverflow or Google
Especially if its an error which is particular to a version of gems or OS

iv) Post on StackOverflow or class forum
Get minimal but complete information which reproduces the error message which you are experiencing and post it.

==Understanding Error Messages in Rails==

===Application Trace===
===Back Trace===
===Full Trace===
===Env Dump and Session Dump===
===Most Common Error Messages in Ruby===

==Interactive Debugger==
===What is an interactive debugger?===

==Conclusion==
==Further Reading==
==References==
https://www.youtube.com/watch?v=Ee5vfe0mLb8

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-17T04:48:27Z

Agarg5: /* Tips to deal with an error */

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-17T04:48:10Z

Agarg5: /* Tips to deal with an error */

==Introduction==
===Debugging in SaaS/Rails can be tricky===
1) Some people are used to printing the error on the terminal(ex. Standard error). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.

2)Errors early in flow might manifest itself late.
For example,
Consider the following hierarchy:
URI -> Route -> Controller -> model -> view -> renderer
Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.
3) Error can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging on Saas depending on the mode of operation.

===Printing to terminal===
In development mode the user is the master and he can easily debug using this approach. This is not possible in production mode though.

===Logging===
This is a more general approach. The logged entries are permanent record of what your application is doing. The recorded errors can also be used to be referenced later. This approach can be used both in the development mode as well as the production mode.

===Interactive Debugging===
In this approach you can stop the application in its track and inspect the variables or other parameters to locate the error.

==RASP==

===Tips to deal with an error===
i) Read the error message carefully.

ii)Ask your colleague an informed question in case you are doing pair programming.

iii) Search using StackOverflow or Google
Especially if its an error which is particular to a version of gems or OS

iv) Post on StackOverflow or class forum
Get minimal but complete information which reproduces the error message which you are experiencing and post it.

==Understanding Error Messages in Rails==

===Application Trace===
===Back Trace===
===Full Trace===
===Env Dump and Session Dump===
===Most Common Error Messages in Ruby===

==Interactive Debugger==
===What is an interactive debugger?===

==Conclusion==
==Further Reading==
==References==

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-17T04:47:33Z

Agarg5: /* Debugging in SaaS/Rails can be tricky */

==Introduction==
===Debugging in SaaS/Rails can be tricky===
1) Some people are used to printing the error on the terminal(ex. Standard error). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.

2)Errors early in flow might manifest itself late.
For example,
Consider the following hierarchy:
URI -> Route -> Controller -> model -> view -> renderer
Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.
3) Error can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging on Saas depending on the mode of operation.

===Printing to terminal===
In development mode the user is the master and he can easily debug using this approach. This is not possible in production mode though.

===Logging===
This is a more general approach. The logged entries are permanent record of what your application is doing. The recorded errors can also be used to be referenced later. This approach can be used both in the development mode as well as the production mode.

===Interactive Debugging===
In this approach you can stop the application in its track and inspect the variables or other parameters to locate the error.

==RASP==

===Tips to deal with an error===
i) Read the error message carefully.
ii)Ask your colleague an informed question in case you are doing pair programming.
iii) Search using StackOverflow or Google
Especially if its an error which is particular to a version of gems or OS
iv) Post on StackOverflow or class forum
Get minimal but complete information which reproduces the error message which you are experiencing and post it.

==Understanding Error Messages in Rails==

===Application Trace===
===Back Trace===
===Full Trace===
===Env Dump and Session Dump===
===Most Common Error Messages in Ruby===

==Interactive Debugger==
===What is an interactive debugger?===

==Conclusion==
==Further Reading==
==References==

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-17T04:45:13Z

Agarg5: /* Debugging in SaaS/Rails can be tricky */

==Introduction==
===Debugging in SaaS/Rails can be tricky===
1) Some people are used to printing the error on the terminal(ex. Standard error). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.\n
2)Errors early in flow might manifest itself late.
For example,
Consider the following hierarchy:
URI -> Route -> Controller -> model -> view -> renderer
Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.
3) Error can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging on Saas depending on the mode of operation.

===Printing to terminal===
In development mode the user is the master and he can easily debug using this approach. This is not possible in production mode though.

===Logging===
This is a more general approach. The logged entries are permanent record of what your application is doing. The recorded errors can also be used to be referenced later. This approach can be used both in the development mode as well as the production mode.

===Interactive Debugging===
In this approach you can stop the application in its track and inspect the variables or other parameters to locate the error.

==RASP==

===Tips to deal with an error===
i) Read the error message carefully.
ii)Ask your colleague an informed question in case you are doing pair programming.
iii) Search using StackOverflow or Google
Especially if its an error which is particular to a version of gems or OS
iv) Post on StackOverflow or class forum
Get minimal but complete information which reproduces the error message which you are experiencing and post it.

==Understanding Error Messages in Rails==

===Application Trace===
===Back Trace===
===Full Trace===
===Env Dump and Session Dump===
===Most Common Error Messages in Ruby===

==Interactive Debugger==
===What is an interactive debugger?===

==Conclusion==
==Further Reading==
==References==

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-17T04:37:22Z

Agarg5: /* Steps of RASP */

==Introduction==
===Debugging in SaaS/Rails can be tricky===
1) Some people are used to printing the error on the terminal(ex. Standard error). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.
2)Errors early in flow might manifest itself late.
For example,
Consider the following hierarchy:
URI -> Route -> Controller -> model -> view -> renderer
Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.
3) Error can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging on Saas depending on the mode of operation.

===Printing to terminal===
In development mode the user is the master and he can easily debug using this approach. This is not possible in production mode though.

===Logging===
This is a more general approach. The logged entries are permanent record of what your application is doing. The recorded errors can also be used to be referenced later. This approach can be used both in the development mode as well as the production mode.

===Interactive Debugging===
In this approach you can stop the application in its track and inspect the variables or other parameters to locate the error.

==RASP==

===Tips to deal with an error===
i) Read the error message carefully.
ii)Ask your colleague an informed question in case you are doing pair programming.
iii) Search using StackOverflow or Google
Especially if its an error which is particular to a version of gems or OS
iv) Post on StackOverflow or class forum
Get minimal but complete information which reproduces the error message which you are experiencing and post it.

==Understanding Error Messages in Rails==

===Application Trace===
===Back Trace===
===Full Trace===
===Env Dump and Session Dump===
===Most Common Error Messages in Ruby===

==Interactive Debugger==
===What is an interactive debugger?===

==Conclusion==
==Further Reading==
==References==

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-17T04:28:05Z

Agarg5: /* Definitions */

==Introduction==
===Debugging in SaaS/Rails can be tricky===
1) Some people are used to printing the error on the terminal(ex. Standard error). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.
2)Errors early in flow might manifest itself late.
For example,
Consider the following hierarchy:
URI -> Route -> Controller -> model -> view -> renderer
Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.
3) Error can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging on Saas depending on the mode of operation.

===Printing to terminal===
In development mode the user is the master and he can easily debug using this approach. This is not possible in production mode though.

===Logging===
This is a more general approach. The logged entries are permanent record of what your application is doing. The recorded errors can also be used to be referenced later. This approach can be used both in the development mode as well as the production mode.

===Interactive Debugging===
In this approach you can stop the application in its track and inspect the variables or other parameters to locate the error.

==RASP==

===Steps of RASP===
i) Read the error message. Really read it.
The error message is trying to tell you something so read it.

ii) Ask colleague
Ask your colleague an informed question in case you are doing pair programming. I am trying to do this and I expected it to do this but I got this other thing instead of foo.

iii) Search using StackOverflow or Google
Especially if its an error which is particular to a version of gems or OS

iv) Post on StackOverflow or class forum
Get minimal but complete information which reproduces the error message which you are experiencing and post it.

==Understanding Error Messages in Rails==

===Application Trace===
===Back Trace===
===Full Trace===
===Env Dump and Session Dump===
===Most Common Error Messages in Ruby===

==Interactive Debugger==
===What is an interactive debugger?===

==Conclusion==
==Further Reading==
==References==

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-17T04:26:05Z

Agarg5: /* 3)Interactive Debugging */

==Introduction==
===Debugging in SaaS/Rails can be tricky===
1) Some people are used to printing the error on the terminal(ex. Standard error). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.
2)Errors early in flow might manifest itself late.
For example,
Consider the following hierarchy:
URI -> Route -> Controller -> model -> view -> renderer
Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.
3) Error can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging on Saas depending on the mode of operation.

===Printing to terminal===
In development mode the user is the master and he can easily debug using this approach. This is not possible in production mode though.

===Logging===
This is a more general approach. The logged entries are permanent record of what your application is doing. The recorded errors can also be used to be referenced later. This approach can be used both in the development mode as well as the production mode.

===Interactive Debugging===
In this approach you can stop the application in its track and inspect the variables or other parameters to locate the error.

===Definitions===

==RASP==

===Steps of RASP===
i) Read the error message. Really read it.
The error message is trying to tell you something so read it.

ii) Ask colleague
Ask your colleague an informed question in case you are doing pair programming. I am trying to do this and I expected it to do this but I got this other thing instead of foo.

iii) Search using StackOverflow or Google
Especially if its an error which is particular to a version of gems or OS

iv) Post on StackOverflow or class forum
Get minimal but complete information which reproduces the error message which you are experiencing and post it.

==Understanding Error Messages in Rails==

===Application Trace===
===Back Trace===
===Full Trace===
===Env Dump and Session Dump===
===Most Common Error Messages in Ruby===

==Interactive Debugger==
===What is an interactive debugger?===

==Conclusion==
==Further Reading==
==References==

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-17T04:25:52Z

Agarg5: /* 2)Logging */

==Introduction==
===Debugging in SaaS/Rails can be tricky===
1) Some people are used to printing the error on the terminal(ex. Standard error). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.
2)Errors early in flow might manifest itself late.
For example,
Consider the following hierarchy:
URI -> Route -> Controller -> model -> view -> renderer
Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.
3) Error can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging on Saas depending on the mode of operation.

===Printing to terminal===
In development mode the user is the master and he can easily debug using this approach. This is not possible in production mode though.

===Logging===
This is a more general approach. The logged entries are permanent record of what your application is doing. The recorded errors can also be used to be referenced later. This approach can be used both in the development mode as well as the production mode.

===3)Interactive Debugging===
In this approach you can stop the application in its track and inspect the variables or other parameters to locate the error.

===Definitions===

==RASP==

===Steps of RASP===
i) Read the error message. Really read it.
The error message is trying to tell you something so read it.

ii) Ask colleague
Ask your colleague an informed question in case you are doing pair programming. I am trying to do this and I expected it to do this but I got this other thing instead of foo.

iii) Search using StackOverflow or Google
Especially if its an error which is particular to a version of gems or OS

iv) Post on StackOverflow or class forum
Get minimal but complete information which reproduces the error message which you are experiencing and post it.

==Understanding Error Messages in Rails==

===Application Trace===
===Back Trace===
===Full Trace===
===Env Dump and Session Dump===
===Most Common Error Messages in Ruby===

==Interactive Debugger==
===What is an interactive debugger?===

==Conclusion==
==Further Reading==
==References==

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-17T04:25:40Z

Agarg5: /* 1)Printing to terminal */

==Introduction==
===Debugging in SaaS/Rails can be tricky===
1) Some people are used to printing the error on the terminal(ex. Standard error). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.
2)Errors early in flow might manifest itself late.
For example,
Consider the following hierarchy:
URI -> Route -> Controller -> model -> view -> renderer
Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.
3) Error can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging on Saas depending on the mode of operation.

===Printing to terminal===
In development mode the user is the master and he can easily debug using this approach. This is not possible in production mode though.

===2)Logging===
This is a more general approach. The logged entries are permanent record of what your application is doing. The recorded errors can also be used to be referenced later. This approach can be used both in the development mode as well as the production mode.
===3)Interactive Debugging===
In this approach you can stop the application in its track and inspect the variables or other parameters to locate the error.

===Definitions===

==RASP==

===Steps of RASP===
i) Read the error message. Really read it.
The error message is trying to tell you something so read it.

ii) Ask colleague
Ask your colleague an informed question in case you are doing pair programming. I am trying to do this and I expected it to do this but I got this other thing instead of foo.

iii) Search using StackOverflow or Google
Especially if its an error which is particular to a version of gems or OS

iv) Post on StackOverflow or class forum
Get minimal but complete information which reproduces the error message which you are experiencing and post it.

==Understanding Error Messages in Rails==

===Application Trace===
===Back Trace===
===Full Trace===
===Env Dump and Session Dump===
===Most Common Error Messages in Ruby===

==Interactive Debugger==
===What is an interactive debugger?===

==Conclusion==
==Further Reading==
==References==

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-17T04:25:26Z

Agarg5: /* Debugging in SaaS/Rails can be tricky */

==Introduction==
===Debugging in SaaS/Rails can be tricky===
1) Some people are used to printing the error on the terminal(ex. Standard error). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.
2)Errors early in flow might manifest itself late.
For example,
Consider the following hierarchy:
URI -> Route -> Controller -> model -> view -> renderer
Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.
3) Error can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging on Saas depending on the mode of operation.

===1)Printing to terminal===
In development mode the user is the master and he can easily debug using this approach. This is not possible in production mode though.
===2)Logging===
This is a more general approach. The logged entries are permanent record of what your application is doing. The recorded errors can also be used to be referenced later. This approach can be used both in the development mode as well as the production mode.
===3)Interactive Debugging===
In this approach you can stop the application in its track and inspect the variables or other parameters to locate the error.

===Definitions===

==RASP==

===Steps of RASP===
i) Read the error message. Really read it.
The error message is trying to tell you something so read it.

ii) Ask colleague
Ask your colleague an informed question in case you are doing pair programming. I am trying to do this and I expected it to do this but I got this other thing instead of foo.

iii) Search using StackOverflow or Google
Especially if its an error which is particular to a version of gems or OS

iv) Post on StackOverflow or class forum
Get minimal but complete information which reproduces the error message which you are experiencing and post it.

==Understanding Error Messages in Rails==

===Application Trace===
===Back Trace===
===Full Trace===
===Env Dump and Session Dump===
===Most Common Error Messages in Ruby===

==Interactive Debugger==
===What is an interactive debugger?===

==Conclusion==
==Further Reading==
==References==

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-17T04:22:37Z

Agarg5: /* Debugging in SaaS/Rails can be tricky */

==Introduction==
===Debugging in SaaS/Rails can be tricky===
1) Some people are used to printing the error on the terminal(ex. Standard error). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.
2)Errors early in flow might manifest itself late.
For example,
Consider the following hierarchy:
URI -> Route -> Controller -> model -> view -> renderer
Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.
3) Error can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging on Saas depending on the mode of operation.
===1)Printing to terminal===
In development mode the user is the master and he can easily debug using this approach. This is not possible in production mode though.
===2)Logging===
This is a more general approach. The logged entries are permanent record of what your application is doing. The recorded errors can also be used to be referenced later. This approach can be used both in the development mode as well as the production mode.
===3)Interactive Debugging===
In this approach you can stop the application in its track and inspect the variables or other parameters to locate the error.

===Definitions===

==RASP==

===Steps of RASP===
i) Read the error message. Really read it.
The error message is trying to tell you something so read it.

ii) Ask colleague
Ask your colleague an informed question in case you are doing pair programming. I am trying to do this and I expected it to do this but I got this other thing instead of foo.

iii) Search using StackOverflow or Google
Especially if its an error which is particular to a version of gems or OS

iv) Post on StackOverflow or class forum
Get minimal but complete information which reproduces the error message which you are experiencing and post it.

==Understanding Error Messages in Rails==

===Application Trace===
===Back Trace===
===Full Trace===
===Env Dump and Session Dump===
===Most Common Error Messages in Ruby===

==Interactive Debugger==
===What is an interactive debugger?===

==Conclusion==
==Further Reading==
==References==

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-17T03:58:46Z

Agarg5: /* Debugging in SaaS/Rails can be tricky */

==Introduction==
===Debugging in SaaS/Rails can be tricky===
1) Some people are used to printing the error on the terminal(ex. Standard error). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.
2)Errors early in flow might manifest itself late.
For example,
Consider the following hierarchy:
URI -> Route -> Controller -> model -> view -> renderer
Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.
3) Error can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging on Saas depending on the type of user.
''1) What Dev? Prod?
Printing to terminal Y
Logging Y Y
Interactive Debugging Y

You can do anything you want in development mode. Print errors to the terminal, which will go by very quickly and it’ll be hard to read. Writing to log file works both in development mode and production mode. Interactive debugger stops the app in its tracks and inspects the state of the variables and then continue.''

===Definitions===

==RASP==

===Steps of RASP===
i) Read the error message. Really read it.
The error message is trying to tell you something so read it.

ii) Ask colleague
Ask your colleague an informed question in case you are doing pair programming. I am trying to do this and I expected it to do this but I got this other thing instead of foo.

iii) Search using StackOverflow or Google
Especially if its an error which is particular to a version of gems or OS

iv) Post on StackOverflow or class forum
Get minimal but complete information which reproduces the error message which you are experiencing and post it.

==Understanding Error Messages in Rails==

===Application Trace===
===Back Trace===
===Full Trace===
===Env Dump and Session Dump===
===Most Common Error Messages in Ruby===

==Interactive Debugger==
===What is an interactive debugger?===

==Conclusion==
==Further Reading==
==References==

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-17T03:57:53Z

Agarg5: /* Introduction */

==Introduction==
===Debugging in SaaS/Rails can be tricky===
1) Some people are used to printing the error on the terminal(ex. Standard error). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.
2)Errors early in flow might manifest itself late.
For example,
Consider the following hierarchy:
URI -> Route -> Controller -> model -> view -> renderer
Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.
3) Error can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging on Saas depending on the type of user.
''1) What Dev? Prod?
Printing to terminal Y
Logging Y Y
Interactive Debugging Y

You can do anything you want in development mode. Print errors to the terminal, which will go by very quickly and it’ll be hard to read. Writing to log file works both in development mode and production mode. Interactive debugger stops the app in its tracks and inspects the state of the variables and then continue.''
===Definitions===

==RASP==

===Steps of RASP===
i) Read the error message. Really read it.
The error message is trying to tell you something so read it.

ii) Ask colleague
Ask your colleague an informed question in case you are doing pair programming. I am trying to do this and I expected it to do this but I got this other thing instead of foo.

iii) Search using StackOverflow or Google
Especially if its an error which is particular to a version of gems or OS

iv) Post on StackOverflow or class forum
Get minimal but complete information which reproduces the error message which you are experiencing and post it.

==Understanding Error Messages in Rails==

===Application Trace===
===Back Trace===
===Full Trace===
===Env Dump and Session Dump===
===Most Common Error Messages in Ruby===

==Interactive Debugger==
===What is an interactive debugger?===

==Conclusion==
==Further Reading==
==References==

CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am

2012-11-17T03:32:57Z

Agarg5: /* RASP */

==Introduction==
===Why debugging in SaaS/Rails is hard?===
===Definitions===

==RASP==

===Steps of RASP===
i) Read the error message. Really read it.
The error message is trying to tell you something so read it.

ii) Ask colleague
Ask your colleague an informed question in case you are doing pair programming. I am trying to do this and I expected it to do this but I got this other thing instead of foo.

iii) Search using StackOverflow or Google
Especially if its an error which is particular to a version of gems or OS

iv) Post on StackOverflow or class forum
Get minimal but complete information which reproduces the error message which you are experiencing and post it.

==Understanding Error Messages in Rails==

===Application Trace===
===Back Trace===
===Full Trace===
===Env Dump and Session Dump===
===Most Common Error Messages in Ruby===

==Interactive Debugger==
===What is an interactive debugger?===

==Conclusion==
==Further Reading==
==References==

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-13T20:48:41Z

Agarg5: /* Ruby */

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

=== C++===
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also allows ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

=== Java ===
There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}

Besides these 8 primitive data types java provides support to character strings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so. One of the major differences in Java from the other languages is that,the size of variables of these primitive types do not vary from one system to another, ie, it is not machine/architecture dependent. Also, Java does not allow numeric values to be stored unsigned[http://www.idevelopment.info/data/Programming/java/miscellaneous_java/Java_Primitive_Types.html].

Also, 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# ===
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

[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> Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| ± 2^30 (for 32-bit systems)
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html]
| values > 2^30 (for 32-bit systems)
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308 (for 32-bit systems)
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

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 using primitive data types==
The various advantages of using primitive data types are as follows:
=== Efficiency ===
Use of primitive data types takes less time to execute than a similar program that executes using object types. This is mainly because, when using object types, a lot of function calls are done implicitly to get the variables necessary for the operation. Consider the following example,

<pre>
Integer a = new Integer(20);
Integer b = new Integer(30);
Integer c = a + b;
</pre>

When <code>a+b</code> is executed, the line implicitly changes to <code>c.valueOf(a.intValue() + b.intValue())</code> on the right hand side[http://chaoticjava.com/posts/autoboxing-tips/]. This increases the number of function calls and so takes up more time to execute. This is the case for all objects. This delay is not present when primitive data types are used as the actual data is fetched from memory instead of calling another function to retrieve it.

=== Ease of use ===
Using primitive data types is much more efficient way of programming than programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].

=== Simplicity ===
Working with primitive data types is more intuitive.

Example:
1. As a counter in a loop. Using objects in this place would make the program difficult to understand and tedious for the programmer.

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

2. In conditional statements.

if(x > max)
max = x;

== Disadvantages ==

=== Lack of inheritance capability ===
The primitive data types in languages such as Java cannot be inherited to create further subtypes as the wrapper classes like Integer, Float, etc are all final. Some applications that use OO languages might require more functionality than what is provided by the primitive datatype. For example, in Java, some of the composite data type like ArrayList, can be extended to add new functions like <code>sum</code>,etc to be used in the application.

<pre>
public class MyArrayList<E> extends ArrayList<e> {
}
</pre>

This provides a lot of customization options that help write more cleaner code. As an exception, the language SmallTalk allows even the basic primitive types to be inherited and modify the operations that can be performed on them.

=== Not Scalable ===
Using primitive datatypes is '''not scalable '''enough for real time applications. For example, a real time application would like to work with a large number of similar or varied type of data. To use primitive types for this scenario would involve creating a lot of variables and maintaining the state of all these variables which is hard to do. Composite objects like arrays or lists can provide easier representation and management of data. For example, to represent a list of variables,

<pre>
char a[5] = {'c','a','d','f',h'};
</pre>

Representing data in this way, allows easy access of the data as a[0], a[1], etc. This type of access by using a single variable to refer to multiple variables and memory locations allows performing similar operations on all the variables together (using loops or similar constructs).

=== Utility Functions ===
The presence of utility functions for composite objects allows a lot of operations to be performed on the data. For example in Java, the ArrayLists class allows any type of data to be stored in them and provides a lot of utility functions. Operations like searching within the list can be performed by simply calling a utility function available, where as the user would have had to write explicit functions had primitive types been used. The generic classes in Java donot allow primitive datatypes to be used as parameters. So, to use an ArrayList of integers in Java, we should use the wrapper class of int (Integer) instead.

<pre>
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(5); // Though '5' is given as a primitive type, java performs Autoboxing to promote it to Integer Object.
list.add(4);
list.add(3);
list.add(2);
list.add(1);
System.out.println(list.contains(5));
</pre>

Output:
true

Performing aggregate operations on a bunch of values is also much easier when composite objects are used. For example, Usage of the Collections framework present in Java allows to perform a lot of operations like sorting the values present in the collection. As the sort operations that are pre-implemented in the Collection framework are in-built java functions, they are extremely fast (order of nlog n).

<pre>
Collections.sort(list);
System.out.println(list);
</pre>

Output:
[1, 2, 3, 4, 5]

Exceptions to this are languages like Ruby, which treat all the basic types as objects and provide utility functions for all of them.

=== Null Values ===
Primitive data types do not allow to hold '''null values'''. So they cannot be used when a check for null value is essential.

=== Unexpected results due to method overriding ===
There are certain examples such as [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html this], which show that overriding inbuilt methods such as == and eql? can lead to unexpected results.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-13T20:45:10Z

Agarg5: /* Ruby */

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

=== C++===
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also allows ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

=== Java ===
There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}

Besides these 8 primitive data types java provides support to character strings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so. One of the major differences in Java from the other languages is that,the size of variables of these primitive types do not vary from one system to another, ie, it is not machine/architecture dependent. Also, Java does not allow numeric values to be stored unsigned[http://www.idevelopment.info/data/Programming/java/miscellaneous_java/Java_Primitive_Types.html].

Also, 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# ===
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

[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>. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| ± 2^30 (for 32-bit systems)
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html]
| values > 2^30 (for 32-bit systems)
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308 (for 32-bit systems)
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

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 using primitive data types==
The various advantages of using primitive data types are as follows:
=== Efficiency ===
Use of primitive data types takes less time to execute than a similar program that executes using object types. This is mainly because, when using object types, a lot of function calls are done implicitly to get the variables necessary for the operation. Consider the following example,

<pre>
Integer a = new Integer(20);
Integer b = new Integer(30);
Integer c = a + b;
</pre>

When <code>a+b</code> is executed, the line implicitly changes to <code>c.valueOf(a.intValue() + b.intValue())</code> on the right hand side[http://chaoticjava.com/posts/autoboxing-tips/]. This increases the number of function calls and so takes up more time to execute. This is the case for all objects. This delay is not present when primitive data types are used as the actual data is fetched from memory instead of calling another function to retrieve it.

=== Ease of use ===
Using primitive data types is much more efficient way of programming than programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].

=== Simplicity ===
Working with primitive data types is more intuitive.

Example:
1. As a counter in a loop. Using objects in this place would make the program difficult to understand and tedious for the programmer.

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

2. In conditional statements.

if(x > max)
max = x;

== Disadvantages ==

=== Lack of inheritance capability ===
The primitive data types in languages such as Java cannot be inherited to create further subtypes as the wrapper classes like Integer, Float, etc are all final. Some applications that use OO languages might require more functionality than what is provided by the primitive datatype. For example, in Java, some of the composite data type like ArrayList, can be extended to add new functions like <code>sum</code>,etc to be used in the application.

<pre>
public class MyArrayList<E> extends ArrayList<e> {
}
</pre>

This provides a lot of customization options that help write more cleaner code. As an exception, the language SmallTalk allows even the basic primitive types to be inherited and modify the operations that can be performed on them.

=== Not Scalable ===
Using primitive datatypes is '''not scalable '''enough for real time applications. For example, a real time application would like to work with a large number of similar or varied type of data. To use primitive types for this scenario would involve creating a lot of variables and maintaining the state of all these variables which is hard to do. Composite objects like arrays or lists can provide easier representation and management of data. For example, to represent a list of variables,

<pre>
char a[5] = {'c','a','d','f',h'};
</pre>

Representing data in this way, allows easy access of the data as a[0], a[1], etc. This type of access by using a single variable to refer to multiple variables and memory locations allows performing similar operations on all the variables together (using loops or similar constructs).

=== Utility Functions ===
The presence of utility functions for composite objects allows a lot of operations to be performed on the data. For example in Java, the ArrayLists class allows any type of data to be stored in them and provides a lot of utility functions. Operations like searching within the list can be performed by simply calling a utility function available, where as the user would have had to write explicit functions had primitive types been used. The generic classes in Java donot allow primitive datatypes to be used as parameters. So, to use an ArrayList of integers in Java, we should use the wrapper class of int (Integer) instead.

<pre>
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(5); // Though '5' is given as a primitive type, java performs Autoboxing to promote it to Integer Object.
list.add(4);
list.add(3);
list.add(2);
list.add(1);
System.out.println(list.contains(5));
</pre>

Output:
true

Performing aggregate operations on a bunch of values is also much easier when composite objects are used. For example, Usage of the Collections framework present in Java allows to perform a lot of operations like sorting the values present in the collection. As the sort operations that are pre-implemented in the Collection framework are in-built java functions, they are extremely fast (order of nlog n).

<pre>
Collections.sort(list);
System.out.println(list);
</pre>

Output:
[1, 2, 3, 4, 5]

Exceptions to this are languages like Ruby, which treat all the basic types as objects and provide utility functions for all of them.

=== Null Values ===
Primitive data types do not allow to hold '''null values'''. So they cannot be used when a check for null value is essential.

=== Unexpected results due to method overriding ===
There are certain examples such as [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html this], which show that overriding inbuilt methods such as == and eql? can lead to unexpected results.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-13T20:41:50Z

Agarg5: /* Java */

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

=== C++===
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also allows ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

=== Java ===
There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}

Besides these 8 primitive data types java provides support to character strings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so. One of the major differences in Java from the other languages is that,the size of variables of these primitive types do not vary from one system to another, ie, it is not machine/architecture dependent. Also, Java does not allow numeric values to be stored unsigned[http://www.idevelopment.info/data/Programming/java/miscellaneous_java/Java_Primitive_Types.html].

Also, 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# ===
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

[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 ===
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| ± 2^30 (for 32-bit systems)
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html]
| values > 2^30 (for 32-bit systems)
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308 (for 32-bit systems)
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

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 using primitive data types==
The various advantages of using primitive data types are as follows:
=== Efficiency ===
Use of primitive data types takes less time to execute than a similar program that executes using object types. This is mainly because, when using object types, a lot of function calls are done implicitly to get the variables necessary for the operation. Consider the following example,

<pre>
Integer a = new Integer(20);
Integer b = new Integer(30);
Integer c = a + b;
</pre>

When <code>a+b</code> is executed, the line implicitly changes to <code>c.valueOf(a.intValue() + b.intValue())</code> on the right hand side[http://chaoticjava.com/posts/autoboxing-tips/]. This increases the number of function calls and so takes up more time to execute. This is the case for all objects. This delay is not present when primitive data types are used as the actual data is fetched from memory instead of calling another function to retrieve it.

=== Ease of use ===
Using primitive data types is much more efficient way of programming than programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].

=== Simplicity ===
Working with primitive data types is more intuitive.

Example:
1. As a counter in a loop. Using objects in this place would make the program difficult to understand and tedious for the programmer.

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

2. In conditional statements.

if(x > max)
max = x;

== Disadvantages ==

=== Lack of inheritance capability ===
The primitive data types in languages such as Java cannot be inherited to create further subtypes as the wrapper classes like Integer, Float, etc are all final. Some applications that use OO languages might require more functionality than what is provided by the primitive datatype. For example, in Java, some of the composite data type like ArrayList, can be extended to add new functions like <code>sum</code>,etc to be used in the application.

<pre>
public class MyArrayList<E> extends ArrayList<e> {
}
</pre>

This provides a lot of customization options that help write more cleaner code. As an exception, the language SmallTalk allows even the basic primitive types to be inherited and modify the operations that can be performed on them.

=== Not Scalable ===
Using primitive datatypes is '''not scalable '''enough for real time applications. For example, a real time application would like to work with a large number of similar or varied type of data. To use primitive types for this scenario would involve creating a lot of variables and maintaining the state of all these variables which is hard to do. Composite objects like arrays or lists can provide easier representation and management of data. For example, to represent a list of variables,

<pre>
char a[5] = {'c','a','d','f',h'};
</pre>

Representing data in this way, allows easy access of the data as a[0], a[1], etc. This type of access by using a single variable to refer to multiple variables and memory locations allows performing similar operations on all the variables together (using loops or similar constructs).

=== Utility Functions ===
The presence of utility functions for composite objects allows a lot of operations to be performed on the data. For example in Java, the ArrayLists class allows any type of data to be stored in them and provides a lot of utility functions. Operations like searching within the list can be performed by simply calling a utility function available, where as the user would have had to write explicit functions had primitive types been used. The generic classes in Java donot allow primitive datatypes to be used as parameters. So, to use an ArrayList of integers in Java, we should use the wrapper class of int (Integer) instead.

<pre>
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(5); // Though '5' is given as a primitive type, java performs Autoboxing to promote it to Integer Object.
list.add(4);
list.add(3);
list.add(2);
list.add(1);
System.out.println(list.contains(5));
</pre>

Output:
true

Performing aggregate operations on a bunch of values is also much easier when composite objects are used. For example, Usage of the Collections framework present in Java allows to perform a lot of operations like sorting the values present in the collection. As the sort operations that are pre-implemented in the Collection framework are in-built java functions, they are extremely fast (order of nlog n).

<pre>
Collections.sort(list);
System.out.println(list);
</pre>

Output:
[1, 2, 3, 4, 5]

Exceptions to this are languages like Ruby, which treat all the basic types as objects and provide utility functions for all of them.

=== Null Values ===
Primitive data types do not allow to hold '''null values'''. So they cannot be used when a check for null value is essential.

=== Unexpected results due to method overriding ===
There are certain examples such as [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html this], which show that overriding inbuilt methods such as == and eql? can lead to unexpected results.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-13T20:40:41Z

Agarg5: /* Java */

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

=== C++===
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also allows ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

=== Java ===
There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so. One of the major differences in Java from the other languages is that,the size of variables of these primitive types do not vary from one system to another, ie, it is not machine/architecture dependent. Also, Java does not allow numeric values to be stored unsigned[http://www.idevelopment.info/data/Programming/java/miscellaneous_java/Java_Primitive_Types.html].

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# ===
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

[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 ===
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| ± 2^30 (for 32-bit systems)
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html]
| values > 2^30 (for 32-bit systems)
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308 (for 32-bit systems)
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

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 using primitive data types==
The various advantages of using primitive data types are as follows:
=== Efficiency ===
Use of primitive data types takes less time to execute than a similar program that executes using object types. This is mainly because, when using object types, a lot of function calls are done implicitly to get the variables necessary for the operation. Consider the following example,

<pre>
Integer a = new Integer(20);
Integer b = new Integer(30);
Integer c = a + b;
</pre>

When <code>a+b</code> is executed, the line implicitly changes to <code>c.valueOf(a.intValue() + b.intValue())</code> on the right hand side[http://chaoticjava.com/posts/autoboxing-tips/]. This increases the number of function calls and so takes up more time to execute. This is the case for all objects. This delay is not present when primitive data types are used as the actual data is fetched from memory instead of calling another function to retrieve it.

=== Ease of use ===
Using primitive data types is much more efficient way of programming than programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].

=== Simplicity ===
Working with primitive data types is more intuitive.

Example:
1. As a counter in a loop. Using objects in this place would make the program difficult to understand and tedious for the programmer.

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

2. In conditional statements.

if(x > max)
max = x;

== Disadvantages ==

=== Lack of inheritance capability ===
The primitive data types in languages such as Java cannot be inherited to create further subtypes as the wrapper classes like Integer, Float, etc are all final. Some applications that use OO languages might require more functionality than what is provided by the primitive datatype. For example, in Java, some of the composite data type like ArrayList, can be extended to add new functions like <code>sum</code>,etc to be used in the application.

<pre>
public class MyArrayList<E> extends ArrayList<e> {
}
</pre>

This provides a lot of customization options that help write more cleaner code. As an exception, the language SmallTalk allows even the basic primitive types to be inherited and modify the operations that can be performed on them.

=== Not Scalable ===
Using primitive datatypes is '''not scalable '''enough for real time applications. For example, a real time application would like to work with a large number of similar or varied type of data. To use primitive types for this scenario would involve creating a lot of variables and maintaining the state of all these variables which is hard to do. Composite objects like arrays or lists can provide easier representation and management of data. For example, to represent a list of variables,

<pre>
char a[5] = {'c','a','d','f',h'};
</pre>

Representing data in this way, allows easy access of the data as a[0], a[1], etc. This type of access by using a single variable to refer to multiple variables and memory locations allows performing similar operations on all the variables together (using loops or similar constructs).

=== Utility Functions ===
The presence of utility functions for composite objects allows a lot of operations to be performed on the data. For example in Java, the ArrayLists class allows any type of data to be stored in them and provides a lot of utility functions. Operations like searching within the list can be performed by simply calling a utility function available, where as the user would have had to write explicit functions had primitive types been used. The generic classes in Java donot allow primitive datatypes to be used as parameters. So, to use an ArrayList of integers in Java, we should use the wrapper class of int (Integer) instead.

<pre>
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(5); // Though '5' is given as a primitive type, java performs Autoboxing to promote it to Integer Object.
list.add(4);
list.add(3);
list.add(2);
list.add(1);
System.out.println(list.contains(5));
</pre>

Output:
true

Performing aggregate operations on a bunch of values is also much easier when composite objects are used. For example, Usage of the Collections framework present in Java allows to perform a lot of operations like sorting the values present in the collection. As the sort operations that are pre-implemented in the Collection framework are in-built java functions, they are extremely fast (order of nlog n).

<pre>
Collections.sort(list);
System.out.println(list);
</pre>

Output:
[1, 2, 3, 4, 5]

Exceptions to this are languages like Ruby, which treat all the basic types as objects and provide utility functions for all of them.

=== Null Values ===
Primitive data types do not allow to hold '''null values'''. So they cannot be used when a check for null value is essential.

=== Unexpected results due to method overriding ===
There are certain examples such as [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html this], which show that overriding inbuilt methods such as == and eql? can lead to unexpected results.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-13T20:39:21Z

Agarg5:

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

=== C++===
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also allows ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

=== Java ===
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so. One of the major differences in Java from the other languages is that,the size of variables of these primitive types do not vary from one system to another, ie, it is not machine/architecture dependent. Also, Java does not allow numeric values to be stored unsigned[http://www.idevelopment.info/data/Programming/java/miscellaneous_java/Java_Primitive_Types.html].

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# ===
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

[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 ===
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| ± 2^30 (for 32-bit systems)
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html]
| values > 2^30 (for 32-bit systems)
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308 (for 32-bit systems)
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

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 using primitive data types==
The various advantages of using primitive data types are as follows:
=== Efficiency ===
Use of primitive data types takes less time to execute than a similar program that executes using object types. This is mainly because, when using object types, a lot of function calls are done implicitly to get the variables necessary for the operation. Consider the following example,

<pre>
Integer a = new Integer(20);
Integer b = new Integer(30);
Integer c = a + b;
</pre>

When <code>a+b</code> is executed, the line implicitly changes to <code>c.valueOf(a.intValue() + b.intValue())</code> on the right hand side[http://chaoticjava.com/posts/autoboxing-tips/]. This increases the number of function calls and so takes up more time to execute. This is the case for all objects. This delay is not present when primitive data types are used as the actual data is fetched from memory instead of calling another function to retrieve it.

=== Ease of use ===
Using primitive data types is much more efficient way of programming than programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].

=== Simplicity ===
Working with primitive data types is more intuitive.

Example:
1. As a counter in a loop. Using objects in this place would make the program difficult to understand and tedious for the programmer.

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

2. In conditional statements.

if(x > max)
max = x;

== Disadvantages ==

=== Lack of inheritance capability ===
The primitive data types in languages such as Java cannot be inherited to create further subtypes as the wrapper classes like Integer, Float, etc are all final. Some applications that use OO languages might require more functionality than what is provided by the primitive datatype. For example, in Java, some of the composite data type like ArrayList, can be extended to add new functions like <code>sum</code>,etc to be used in the application.

<pre>
public class MyArrayList<E> extends ArrayList<e> {
}
</pre>

This provides a lot of customization options that help write more cleaner code. As an exception, the language SmallTalk allows even the basic primitive types to be inherited and modify the operations that can be performed on them.

=== Not Scalable ===
Using primitive datatypes is '''not scalable '''enough for real time applications. For example, a real time application would like to work with a large number of similar or varied type of data. To use primitive types for this scenario would involve creating a lot of variables and maintaining the state of all these variables which is hard to do. Composite objects like arrays or lists can provide easier representation and management of data. For example, to represent a list of variables,

<pre>
char a[5] = {'c','a','d','f',h'};
</pre>

Representing data in this way, allows easy access of the data as a[0], a[1], etc. This type of access by using a single variable to refer to multiple variables and memory locations allows performing similar operations on all the variables together (using loops or similar constructs).

=== Utility Functions ===
The presence of utility functions for composite objects allows a lot of operations to be performed on the data. For example in Java, the ArrayLists class allows any type of data to be stored in them and provides a lot of utility functions. Operations like searching within the list can be performed by simply calling a utility function available, where as the user would have had to write explicit functions had primitive types been used. The generic classes in Java donot allow primitive datatypes to be used as parameters. So, to use an ArrayList of integers in Java, we should use the wrapper class of int (Integer) instead.

<pre>
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(5); // Though '5' is given as a primitive type, java performs Autoboxing to promote it to Integer Object.
list.add(4);
list.add(3);
list.add(2);
list.add(1);
System.out.println(list.contains(5));
</pre>

Output:
true

Performing aggregate operations on a bunch of values is also much easier when composite objects are used. For example, Usage of the Collections framework present in Java allows to perform a lot of operations like sorting the values present in the collection. As the sort operations that are pre-implemented in the Collection framework are in-built java functions, they are extremely fast (order of nlog n).

<pre>
Collections.sort(list);
System.out.println(list);
</pre>

Output:
[1, 2, 3, 4, 5]

Exceptions to this are languages like Ruby, which treat all the basic types as objects and provide utility functions for all of them.

=== Null Values ===
Primitive data types do not allow to hold '''null values'''. So they cannot be used when a check for null value is essential.

=== Unexpected results due to method overriding ===
There are certain examples such as [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html this], which show that overriding inbuilt methods such as == and eql? can lead to unexpected results.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-13T20:35:57Z

Agarg5: /* JavaScript */

'''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 data types in C++ ==
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also allows ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

== Primitive data types in Java ==
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so. One of the major differences in Java from the other languages is that,the size of variables of these primitive types do not vary from one system to another, ie, it is not machine/architecture dependent. Also, Java does not allow numeric values to be stored unsigned[http://www.idevelopment.info/data/Programming/java/miscellaneous_java/Java_Primitive_Types.html].

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

== Primitive data types in C# ==
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

[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
}

== Primitive data types in 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

== Primitive data types/objects in Ruby ==
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| ± 2^30 (for 32-bit systems)
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html]
| values > 2^30 (for 32-bit systems)
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308 (for 32-bit systems)
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

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 using primitive data types==
The various advantages of using primitive data types are as follows:
=== Efficiency ===
Use of primitive data types takes less time to execute than a similar program that executes using object types. This is mainly because, when using object types, a lot of function calls are done implicitly to get the variables necessary for the operation. Consider the following example,

<pre>
Integer a = new Integer(20);
Integer b = new Integer(30);
Integer c = a + b;
</pre>

When <code>a+b</code> is executed, the line implicitly changes to <code>c.valueOf(a.intValue() + b.intValue())</code> on the right hand side[http://chaoticjava.com/posts/autoboxing-tips/]. This increases the number of function calls and so takes up more time to execute. This is the case for all objects. This delay is not present when primitive data types are used as the actual data is fetched from memory instead of calling another function to retrieve it.

=== Ease of use ===
Using primitive data types is much more efficient way of programming than programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].

=== Simplicity ===
Working with primitive data types is more intuitive.

Example:
1. As a counter in a loop. Using objects in this place would make the program difficult to understand and tedious for the programmer.

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

2. In conditional statements.

if(x > max)
max = x;

== Disadvantages ==

=== Lack of inheritance capability ===
The primitive data types in languages such as Java cannot be inherited to create further subtypes as the wrapper classes like Integer, Float, etc are all final. Some applications that use OO languages might require more functionality than what is provided by the primitive datatype. For example, in Java, some of the composite data type like ArrayList, can be extended to add new functions like <code>sum</code>,etc to be used in the application.

<pre>
public class MyArrayList<E> extends ArrayList<e> {
}
</pre>

This provides a lot of customization options that help write more cleaner code. As an exception, the language SmallTalk allows even the basic primitive types to be inherited and modify the operations that can be performed on them.

=== Not Scalable ===
Using primitive datatypes is '''not scalable '''enough for real time applications. For example, a real time application would like to work with a large number of similar or varied type of data. To use primitive types for this scenario would involve creating a lot of variables and maintaining the state of all these variables which is hard to do. Composite objects like arrays or lists can provide easier representation and management of data. For example, to represent a list of variables,

<pre>
char a[5] = {'c','a','d','f',h'};
</pre>

Representing data in this way, allows easy access of the data as a[0], a[1], etc. This type of access by using a single variable to refer to multiple variables and memory locations allows performing similar operations on all the variables together (using loops or similar constructs).

=== Utility Functions ===
The presence of utility functions for composite objects allows a lot of operations to be performed on the data. For example in Java, the ArrayLists class allows any type of data to be stored in them and provides a lot of utility functions. Operations like searching within the list can be performed by simply calling a utility function available, where as the user would have had to write explicit functions had primitive types been used. The generic classes in Java donot allow primitive datatypes to be used as parameters. So, to use an ArrayList of integers in Java, we should use the wrapper class of int (Integer) instead.

<pre>
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(5); // Though '5' is given as a primitive type, java performs Autoboxing to promote it to Integer Object.
list.add(4);
list.add(3);
list.add(2);
list.add(1);
System.out.println(list.contains(5));
</pre>

Output:
true

Performing aggregate operations on a bunch of values is also much easier when composite objects are used. For example, Usage of the Collections framework present in Java allows to perform a lot of operations like sorting the values present in the collection. As the sort operations that are pre-implemented in the Collection framework are in-built java functions, they are extremely fast (order of nlog n).

<pre>
Collections.sort(list);
System.out.println(list);
</pre>

Output:
[1, 2, 3, 4, 5]

Exceptions to this are languages like Ruby, which treat all the basic types as objects and provide utility functions for all of them.

=== Null Values ===
Primitive data types do not allow to hold '''null values'''. So they cannot be used when a check for null value is essential.

=== Unexpected results due to method overriding ===
There are certain examples such as [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html this], which show that overriding inbuilt methods such as == and eql? can lead to unexpected results.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-13T20:34:39Z

Agarg5:

'''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 data types in C++ ==
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also allows ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

== Primitive data types in Java ==
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so. One of the major differences in Java from the other languages is that,the size of variables of these primitive types do not vary from one system to another, ie, it is not machine/architecture dependent. Also, Java does not allow numeric values to be stored unsigned[http://www.idevelopment.info/data/Programming/java/miscellaneous_java/Java_Primitive_Types.html].

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

== Primitive data types in C# ==
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

[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

== Primitive data types/objects in Ruby ==
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| ± 2^30 (for 32-bit systems)
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html]
| values > 2^30 (for 32-bit systems)
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308 (for 32-bit systems)
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

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 using primitive data types==
The various advantages of using primitive data types are as follows:
=== Efficiency ===
Use of primitive data types takes less time to execute than a similar program that executes using object types. This is mainly because, when using object types, a lot of function calls are done implicitly to get the variables necessary for the operation. Consider the following example,

<pre>
Integer a = new Integer(20);
Integer b = new Integer(30);
Integer c = a + b;
</pre>

When <code>a+b</code> is executed, the line implicitly changes to <code>c.valueOf(a.intValue() + b.intValue())</code> on the right hand side[http://chaoticjava.com/posts/autoboxing-tips/]. This increases the number of function calls and so takes up more time to execute. This is the case for all objects. This delay is not present when primitive data types are used as the actual data is fetched from memory instead of calling another function to retrieve it.

=== Ease of use ===
Using primitive data types is much more efficient way of programming than programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].

=== Simplicity ===
Working with primitive data types is more intuitive.

Example:
1. As a counter in a loop. Using objects in this place would make the program difficult to understand and tedious for the programmer.

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

2. In conditional statements.

if(x > max)
max = x;

== Disadvantages ==

=== Lack of inheritance capability ===
The primitive data types in languages such as Java cannot be inherited to create further subtypes as the wrapper classes like Integer, Float, etc are all final. Some applications that use OO languages might require more functionality than what is provided by the primitive datatype. For example, in Java, some of the composite data type like ArrayList, can be extended to add new functions like <code>sum</code>,etc to be used in the application.

<pre>
public class MyArrayList<E> extends ArrayList<e> {
}
</pre>

This provides a lot of customization options that help write more cleaner code. As an exception, the language SmallTalk allows even the basic primitive types to be inherited and modify the operations that can be performed on them.

=== Not Scalable ===
Using primitive datatypes is '''not scalable '''enough for real time applications. For example, a real time application would like to work with a large number of similar or varied type of data. To use primitive types for this scenario would involve creating a lot of variables and maintaining the state of all these variables which is hard to do. Composite objects like arrays or lists can provide easier representation and management of data. For example, to represent a list of variables,

<pre>
char a[5] = {'c','a','d','f',h'};
</pre>

Representing data in this way, allows easy access of the data as a[0], a[1], etc. This type of access by using a single variable to refer to multiple variables and memory locations allows performing similar operations on all the variables together (using loops or similar constructs).

=== Utility Functions ===
The presence of utility functions for composite objects allows a lot of operations to be performed on the data. For example in Java, the ArrayLists class allows any type of data to be stored in them and provides a lot of utility functions. Operations like searching within the list can be performed by simply calling a utility function available, where as the user would have had to write explicit functions had primitive types been used. The generic classes in Java donot allow primitive datatypes to be used as parameters. So, to use an ArrayList of integers in Java, we should use the wrapper class of int (Integer) instead.

<pre>
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(5); // Though '5' is given as a primitive type, java performs Autoboxing to promote it to Integer Object.
list.add(4);
list.add(3);
list.add(2);
list.add(1);
System.out.println(list.contains(5));
</pre>

Output:
true

Performing aggregate operations on a bunch of values is also much easier when composite objects are used. For example, Usage of the Collections framework present in Java allows to perform a lot of operations like sorting the values present in the collection. As the sort operations that are pre-implemented in the Collection framework are in-built java functions, they are extremely fast (order of nlog n).

<pre>
Collections.sort(list);
System.out.println(list);
</pre>

Output:
[1, 2, 3, 4, 5]

Exceptions to this are languages like Ruby, which treat all the basic types as objects and provide utility functions for all of them.

=== Null Values ===
Primitive data types do not allow to hold '''null values'''. So they cannot be used when a check for null value is essential.

=== Unexpected results due to method overriding ===
There are certain examples such as [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html this], which show that overriding inbuilt methods such as == and eql? can lead to unexpected results.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-13T20:28:45Z

Agarg5:

'''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 data types in C++ ==
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also allows ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

== Primitive data types in Java ==
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so. One of the major differences in Java from the other languages is that,the size of variables of these primitive types do not vary from one system to another, ie, it is not machine/architecture dependent. Also, Java does not allow numeric values to be stored unsigned[http://www.idevelopment.info/data/Programming/java/miscellaneous_java/Java_Primitive_Types.html].

Java provides wrapper classes for these primitive types and objects of those classes form primitive objects. For example, for the primitive data type ''int'', the Integer class acts as a wrapper class that provides a lot of utility methods like <code>parseInt()</code> and constants like <code>MAX_VALUE</code> and <code>MIN_VALUE</code> that can be used on an Integer object. The other wrapper classes that Java provides for these primitive classes are Integer, Double, Float, Character, Boolean, Long and Short.

int i = Integer.parseInt("50");
System.out.println(i);
System.out.println(Integer.MAX_VALUE);

Output:
50
2147483647

== Primitive data types in C# ==
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

== Primitive data types/objects in Ruby ==
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| ± 2^30 (for 32-bit systems)
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html]
| values > 2^30 (for 32-bit systems)
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308 (for 32-bit systems)
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

==Advantages of using primitive data types==
The various advantages of using primitive data types are as follows:
=== Efficiency ===
Use of primitive data types takes less time to execute than a similar program that executes using object types. This is mainly because, when using object types, a lot of function calls are done implicitly to get the variables necessary for the operation. Consider the following example,

<pre>
Integer a = new Integer(20);
Integer b = new Integer(30);
Integer c = a + b;
</pre>

When <code>a+b</code> is executed, the line implicitly changes to <code>c.valueOf(a.intValue() + b.intValue())</code> on the right hand side[http://chaoticjava.com/posts/autoboxing-tips/]. This increases the number of function calls and so takes up more time to execute. This is the case for all objects. This delay is not present when primitive data types are used as the actual data is fetched from memory instead of calling another function to retrieve it.

=== Ease of use ===
Using primitive data types is much more efficient way of programming than programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].

=== Simplicity ===
Working with primitive data types is more intuitive.

Example:
1. As a counter in a loop. Using objects in this place would make the program difficult to understand and tedious for the programmer.

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

2. In conditional statements.

if(x > max)
max = x;

== Disadvantages ==

=== Lack of inheritance capability ===
The primitive data types in languages such as Java cannot be inherited to create further subtypes as the wrapper classes like Integer, Float, etc are all final. Some applications that use OO languages might require more functionality than what is provided by the primitive datatype. For example, in Java, some of the composite data type like ArrayList, can be extended to add new functions like <code>sum</code>,etc to be used in the application.

<pre>
public class MyArrayList<E> extends ArrayList<e> {
}
</pre>

This provides a lot of customization options that help write more cleaner code. As an exception, the language SmallTalk allows even the basic primitive types to be inherited and modify the operations that can be performed on them.

=== Not Scalable ===
Using primitive datatypes is '''not scalable '''enough for real time applications. For example, a real time application would like to work with a large number of similar or varied type of data. To use primitive types for this scenario would involve creating a lot of variables and maintaining the state of all these variables which is hard to do. Composite objects like arrays or lists can provide easier representation and management of data. For example, to represent a list of variables,

<pre>
char a[5] = {'c','a','d','f',h'};
</pre>

Representing data in this way, allows easy access of the data as a[0], a[1], etc. This type of access by using a single variable to refer to multiple variables and memory locations allows performing similar operations on all the variables together (using loops or similar constructs).

=== Utility Functions ===
The presence of utility functions for composite objects allows a lot of operations to be performed on the data. For example in Java, the ArrayLists class allows any type of data to be stored in them and provides a lot of utility functions. Operations like searching within the list can be performed by simply calling a utility function available, where as the user would have had to write explicit functions had primitive types been used. The generic classes in Java donot allow primitive datatypes to be used as parameters. So, to use an ArrayList of integers in Java, we should use the wrapper class of int (Integer) instead.

<pre>
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(5); // Though '5' is given as a primitive type, java performs Autoboxing to promote it to Integer Object.
list.add(4);
list.add(3);
list.add(2);
list.add(1);
System.out.println(list.contains(5));
</pre>

Output:
true

Performing aggregate operations on a bunch of values is also much easier when composite objects are used. For example, Usage of the Collections framework present in Java allows to perform a lot of operations like sorting the values present in the collection. As the sort operations that are pre-implemented in the Collection framework are in-built java functions, they are extremely fast (order of nlog n).

<pre>
Collections.sort(list);
System.out.println(list);
</pre>

Output:
[1, 2, 3, 4, 5]

Exceptions to this are languages like Ruby, which treat all the basic types as objects and provide utility functions for all of them.

=== Null Values ===
Primitive data types do not allow to hold '''null values'''. So they cannot be used when a check for null value is essential.

=== Unexpected results due to method overriding ===
There are certain examples such as [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html this], which show that overriding inbuilt methods such as == and eql? can lead to unexpected results.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-13T06:01:05Z

Agarg5: /* Do not have utility functions associated with them */

''' Primitive Objects '''

== Introduction ==
Primitive datatypes are those data types that are not defined in terms of other data types[http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf]. They are basic or in-built types that a programming language provides for its users. These data types can be used for building other complex and composite data types [http://en.wikipedia.org/wiki/Primitive_data_type]. In most languages, primitive types usually consist of basic value types for representing the data to be stored. As these data types are built-in, the compilers for these languages provide more support for them by supporting most basic operations. In dynamically typed languages like Ruby, these data types are represented as objects and are referred to as primitive objects. This article discusses the various primitive data types/objects that are present in various objected oriented programming languages and their benefits.

Some of the common data types that are present in most programming languages are
*'''Integer''' - used to hold whole numbers. Can be signed or unsigned and include various types like <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>, etc.
*'''Character''' - used to hold single character, digit or symbol or a sequence of any combination of them that is stored in numeric coding. Usually stored in ASCII encoding. '
*'''Floating-point''' - used to represent real numbers with limited precision. They usually comprise of an exponent part and a fractional part. Can be signed or unsigned .
*'''Fixed-point''' - similar to floating-point, but has fixed number of digits after the decimal point [http://en.wikipedia.org/wiki/Fixed-point_arithmetic]. They are used in processors or representing base 2 and base 10 fractional values where there is no Floating point unit.
*'''Boolean''' - used to represent logical values for comparisons. Typically hold either of 2 values - true/false. Can also be represented as integers. Can be stored in a single bit, but typically stored as a byte.

== Primitive data types in C++ ==
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also allows ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

== Primitive data types in Java ==
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so. One of the major differences in Java from the other languages is that,the size of variables of these primitive types do not vary from one system to another, ie, it is not machine/architecture dependent. Also, Java does not allow numeric values to be stored unsigned[http://www.idevelopment.info/data/Programming/java/miscellaneous_java/Java_Primitive_Types.html].

Java provides wrapper classes for these primitive types and objects of those classes form primitive objects. For example, for the primitive data type ''int'', the Integer class acts as a wrapper class that provides a lot of utility methods like <code>parseInt()</code> and constants like <code>MAX_VALUE</code> and <code>MIN_VALUE</code> that can be used on an Integer object. The other wrapper classes that Java provides for these primitive classes are Integer, Double, Float, Character, Boolean, Long and Short.

int i = Integer.parseInt("50");
System.out.println(i);
System.out.println(Integer.MAX_VALUE);

Output:
50
2147483647

== Primitive data types in C# ==
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

== Primitive data types/objects in Ruby ==
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| ± 2^30 (for 32-bit systems)
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html]
| values > 2^30 (for 32-bit systems)
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308 (for 32-bit systems)
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

==Advantages of using primitive data types==
The various advantages of using primitive data types are as follows:
=== Ease of use ===
Using primitive data types is much more efficient way of programming than programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].
=== Simplicity ===
Working with primitive data types is more intuitive.

Example:
1. As a counter in a loop.

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

2. In conditional statements.

if(x > max)
max = x;

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

=== Primitive objects cannot be extended ===
Most of the object oriented programming languages do not allow the behavior or capabilities of primitive data types to be modified by programs.For example, the primitive data types in languages such as Java cannot be inherited to create further subtypes. An exception to this includes Smalltalk. It allows all data types to be extended within a program. It allows the programmer to modify the operations that can be performed on them and also to redefine the built in operations.

=== Primitive objects do not have utility functions associated with them===
Most of the object oriented languages have certain utility functions associated with non primitive data types that eases their use as compared to primitive data types that do not have such functions.

Example:

The complex data types like arrays have functions associated with them.

array.length();

However, this is not the case in pure objected oriented languages like Ruby, which provide a utility functions to primitive types as well.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-13T06:00:24Z

Agarg5: /* Disadvantages of using primitive data types */

''' Primitive Objects '''

== Introduction ==
Primitive datatypes are those data types that are not defined in terms of other data types[http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf]. They are basic or in-built types that a programming language provides for its users. These data types can be used for building other complex and composite data types [http://en.wikipedia.org/wiki/Primitive_data_type]. In most languages, primitive types usually consist of basic value types for representing the data to be stored. As these data types are built-in, the compilers for these languages provide more support for them by supporting most basic operations. In dynamically typed languages like Ruby, these data types are represented as objects and are referred to as primitive objects. This article discusses the various primitive data types/objects that are present in various objected oriented programming languages and their benefits.

Some of the common data types that are present in most programming languages are
*'''Integer''' - used to hold whole numbers. Can be signed or unsigned and include various types like <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>, etc.
*'''Character''' - used to hold single character, digit or symbol or a sequence of any combination of them that is stored in numeric coding. Usually stored in ASCII encoding. '
*'''Floating-point''' - used to represent real numbers with limited precision. They usually comprise of an exponent part and a fractional part. Can be signed or unsigned .
*'''Fixed-point''' - similar to floating-point, but has fixed number of digits after the decimal point [http://en.wikipedia.org/wiki/Fixed-point_arithmetic]. They are used in processors or representing base 2 and base 10 fractional values where there is no Floating point unit.
*'''Boolean''' - used to represent logical values for comparisons. Typically hold either of 2 values - true/false. Can also be represented as integers. Can be stored in a single bit, but typically stored as a byte.

== Primitive data types in C++ ==
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also allows ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

== Primitive data types in Java ==
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so. One of the major differences in Java from the other languages is that,the size of variables of these primitive types do not vary from one system to another, ie, it is not machine/architecture dependent. Also, Java does not allow numeric values to be stored unsigned[http://www.idevelopment.info/data/Programming/java/miscellaneous_java/Java_Primitive_Types.html].

Java provides wrapper classes for these primitive types and objects of those classes form primitive objects. For example, for the primitive data type ''int'', the Integer class acts as a wrapper class that provides a lot of utility methods like <code>parseInt()</code> and constants like <code>MAX_VALUE</code> and <code>MIN_VALUE</code> that can be used on an Integer object. The other wrapper classes that Java provides for these primitive classes are Integer, Double, Float, Character, Boolean, Long and Short.

int i = Integer.parseInt("50");
System.out.println(i);
System.out.println(Integer.MAX_VALUE);

Output:
50
2147483647

== Primitive data types in C# ==
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

== Primitive data types/objects in Ruby ==
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| ± 2^30 (for 32-bit systems)
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html]
| values > 2^30 (for 32-bit systems)
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308 (for 32-bit systems)
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

==Advantages of using primitive data types==
The various advantages of using primitive data types are as follows:
=== Ease of use ===
Using primitive data types is much more efficient way of programming than programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].
=== Simplicity ===
Working with primitive data types is more intuitive.

Example:
1. As a counter in a loop.

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

2. In conditional statements.

if(x > max)
max = x;

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

=== Primitive objects cannot be extended ===
Most of the object oriented programming languages do not allow the behavior or capabilities of primitive data types to be modified by programs.For example, the primitive data types in languages such as Java cannot be inherited to create further subtypes. An exception to this includes Smalltalk. It allows all data types to be extended within a program. It allows the programmer to modify the operations that can be performed on them and also to redefine the built in operations.

=== Do not have utility functions associated with them===
Most of the object oriented languages have certain utility functions associated with non primitive data types that eases their use as compared to primitive data types that do not have such functions.

Example:

The complex data types like arrays have functions associated with them.

array.length();

However, this is not the case in pure objected oriented languages like Ruby, which provide a utility functions to primitive types as well.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-13T05:56:08Z

Agarg5: /* Simplicity */

''' Primitive Objects '''

== Introduction ==
Primitive datatypes are those data types that are not defined in terms of other data types[http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf]. They are basic or in-built types that a programming language provides for its users. These data types can be used for building other complex and composite data types [http://en.wikipedia.org/wiki/Primitive_data_type]. In most languages, primitive types usually consist of basic value types for representing the data to be stored. As these data types are built-in, the compilers for these languages provide more support for them by supporting most basic operations. In dynamically typed languages like Ruby, these data types are represented as objects and are referred to as primitive objects. This article discusses the various primitive data types/objects that are present in various objected oriented programming languages and their benefits.

Some of the common data types that are present in most programming languages are
*'''Integer''' - used to hold whole numbers. Can be signed or unsigned and include various types like <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>, etc.
*'''Character''' - used to hold single character, digit or symbol or a sequence of any combination of them that is stored in numeric coding. Usually stored in ASCII encoding. '
*'''Floating-point''' - used to represent real numbers with limited precision. They usually comprise of an exponent part and a fractional part. Can be signed or unsigned .
*'''Fixed-point''' - similar to floating-point, but has fixed number of digits after the decimal point [http://en.wikipedia.org/wiki/Fixed-point_arithmetic]. They are used in processors or representing base 2 and base 10 fractional values where there is no Floating point unit.
*'''Boolean''' - used to represent logical values for comparisons. Typically hold either of 2 values - true/false. Can also be represented as integers. Can be stored in a single bit, but typically stored as a byte.

== Primitive data types in C++ ==
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also allows ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

== Primitive data types in Java ==
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so. One of the major differences in Java from the other languages is that,the size of variables of these primitive types do not vary from one system to another, ie, it is not machine/architecture dependent. Also, Java does not allow numeric values to be stored unsigned[http://www.idevelopment.info/data/Programming/java/miscellaneous_java/Java_Primitive_Types.html].

Java provides wrapper classes for these primitive types and objects of those classes form primitive objects. For example, for the primitive data type ''int'', the Integer class acts as a wrapper class that provides a lot of utility methods like <code>parseInt()</code> and constants like <code>MAX_VALUE</code> and <code>MIN_VALUE</code> that can be used on an Integer object. The other wrapper classes that Java provides for these primitive classes are Integer, Double, Float, Character, Boolean, Long and Short.

int i = Integer.parseInt("50");
System.out.println(i);
System.out.println(Integer.MAX_VALUE);

Output:
50
2147483647

== Primitive data types in C# ==
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

== Primitive data types/objects in Ruby ==
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| ± 2^30 (for 32-bit systems)
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html]
| values > 2^30 (for 32-bit systems)
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308 (for 32-bit systems)
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

==Advantages of using primitive data types==
The various advantages of using primitive data types are as follows:
=== Ease of use ===
Using primitive data types is much more efficient way of programming than programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].
=== Simplicity ===
Working with primitive data types is more intuitive.

Example:
1. As a counter in a loop.

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

2. In conditional statements.

if(x > max)
max = x;

==Disadvantages of using primitive data types==
The various disadvantages of using the primitive data types are as follows:
* Most of the object oriented programming languages do not allow the behavior or capabilities of primitive data types to be modified by programs.For example, the primitive data types in languages such as Java cannot be inherited to create further subtypes. An exception to this includes Smlltalk. It allows all data types to be extended within a program. It allows the programmer to modify the operations that can be performed on them and also to redefine the built in operations.
* Most of the object oriented languages have certain utility functions associated with non primitive data types that eases their use as compared to primitive data types that do not have such functions. This is not the case in pure objected oriented languages like Ruby, which provide a utility functions to primitive types as well.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-13T05:44:48Z

Agarg5:

''' Primitive Objects '''

== Introduction ==
Primitive datatypes are those data types that are not defined in terms of other data types[http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf]. They are basic or in-built types that a programming language provides for its users. These data types can be used for building other complex and composite data types [http://en.wikipedia.org/wiki/Primitive_data_type]. In most languages, primitive types usually consist of basic value types for representing the data to be stored. As these data types are built-in, the compilers for these languages provide more support for them by supporting most basic operations. In dynamically typed languages like Ruby, these data types are represented as objects and are referred to as primitive objects. This article discusses the various primitive data types/objects that are present in various objected oriented programming languages and their benefits.

Some of the common data types that are present in most programming languages are
*'''Integer''' - used to hold whole numbers. Can be signed or unsigned and include various types like <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>, etc.
*'''Character''' - used to hold single character, digit or symbol or a sequence of any combination of them that is stored in numeric coding. Usually stored in ASCII encoding. '
*'''Floating-point''' - used to represent real numbers with limited precision. They usually comprise of an exponent part and a fractional part. Can be signed or unsigned .
*'''Fixed-point''' - similar to floating-point, but has fixed number of digits after the decimal point [http://en.wikipedia.org/wiki/Fixed-point_arithmetic]. They are used in processors or representing base 2 and base 10 fractional values where there is no Floating point unit.
*'''Boolean''' - used to represent logical values for comparisons. Typically hold either of 2 values - true/false. Can also be represented as integers. Can be stored in a single bit, but typically stored as a byte.

== Primitive data types in C++ ==
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also allows ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

== Primitive data types in Java ==
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so. One of the major differences in Java from the other languages is that,the size of variables of these primitive types do not vary from one system to another, ie, it is not machine/architecture dependent. Also, Java does not allow numeric values to be stored unsigned[http://www.idevelopment.info/data/Programming/java/miscellaneous_java/Java_Primitive_Types.html].

Java provides wrapper classes for these primitive types and objects of those classes form primitive objects. For example, for the primitive data type ''int'', the Integer class acts as a wrapper class that provides a lot of utility methods like <code>parseInt()</code> and constants like <code>MAX_VALUE</code> and <code>MIN_VALUE</code> that can be used on an Integer object. The other wrapper classes that Java provides for these primitive classes are Integer, Double, Float, Character, Boolean, Long and Short.

int i = Integer.parseInt("50");
System.out.println(i);
System.out.println(Integer.MAX_VALUE);

Output:
50
2147483647

== Primitive data types in C# ==
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

== Primitive data types/objects in Ruby ==
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| ± 2^30 (for 32-bit systems)
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html]
| values > 2^30 (for 32-bit systems)
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308 (for 32-bit systems)
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

==Advantages of using primitive data types==
The various advantages of using primitive data types are as follows:
=== Ease of use ===
Using primitive data types is much more efficient way of programming than programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].
=== Simplicity ===
Working with primitive data types is more intuitive.

==Disadvantages of using primitive data types==
The various disadvantages of using the primitive data types are as follows:
* Most of the object oriented programming languages do not allow the behavior or capabilities of primitive data types to be modified by programs.For example, the primitive data types in languages such as Java cannot be inherited to create further subtypes. An exception to this includes Smlltalk. It allows all data types to be extended within a program. It allows the programmer to modify the operations that can be performed on them and also to redefine the built in operations.
* Most of the object oriented languages have certain utility functions associated with non primitive data types that eases their use as compared to primitive data types that do not have such functions. This is not the case in pure objected oriented languages like Ruby, which provide a utility functions to primitive types as well.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-13T05:43:10Z

Agarg5:

''' Primitive Objects '''

== Introduction ==
Primitive datatypes are those data types that are not defined in terms of other data types[http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf]. They are basic or in-built types that a programming language provides for its users. These data types can be used for building other complex and composite data types [http://en.wikipedia.org/wiki/Primitive_data_type]. In most languages, primitive types usually consist of basic value types for representing the data to be stored. As these data types are built-in, the compilers for these languages provide more support for them by supporting most basic operations. In dynamically typed languages like Ruby, these data types are represented as objects and are referred to as primitive objects. This article discusses the various primitive data types/objects that are present in various objected oriented programming languages and their benefits.

Some of the common data types that are present in most programming languages are
*'''Integer''' - used to hold whole numbers. Can be signed or unsigned and include various types like <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>, etc.
*'''Character''' - used to hold single character, digit or symbol or a sequence of any combination of them that is stored in numeric coding. Usually stored in ASCII encoding. '
*'''Floating-point''' - used to represent real numbers with limited precision. They usually comprise of an exponent part and a fractional part. Can be signed or unsigned .
*'''Fixed-point''' - similar to floating-point, but has fixed number of digits after the decimal point [http://en.wikipedia.org/wiki/Fixed-point_arithmetic]. They are used in processors or representing base 2 and base 10 fractional values where there is no Floating point unit.
*'''Boolean''' - used to represent logical values for comparisons. Typically hold either of 2 values - true/false. Can also be represented as integers. Can be stored in a single bit, but typically stored as a byte.

== Primitive data types in C++ ==
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also allows ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

== Primitive data types in Java ==
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so. One of the major differences in Java from the other languages is that,the size of variables of these primitive types do not vary from one system to another, ie, it is not machine/architecture dependent. Also, Java does not allow numeric values to be stored unsigned[http://www.idevelopment.info/data/Programming/java/miscellaneous_java/Java_Primitive_Types.html].

Java provides wrapper classes for these primitive types and objects of those classes form primitive objects. For example, for the primitive data type ''int'', the Integer class acts as a wrapper class that provides a lot of utility methods like <code>parseInt()</code> and constants like <code>MAX_VALUE</code> and <code>MIN_VALUE</code> that can be used on an Integer object. The other wrapper classes that Java provides for these primitive classes are Integer, Double, Float, Character, Boolean, Long and Short.

int i = Integer.parseInt("50");
System.out.println(i);
System.out.println(Integer.MAX_VALUE);

Output:
50
2147483647

== Primitive data types in C# ==
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

== Primitive data types/objects in Ruby ==
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| ± 2^30 (for 32-bit systems)
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html]
| values > 2^30 (for 32-bit systems)
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308 (for 32-bit systems)
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

==Advantages of Primitive data types==
The various advantages of using primitive data types are as follows:
=== Ease of use ===
Using primitive data types is much more efficient way of programming than programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].
=== Simplicity ===
Working with primitive data types is more intuitive.

===Disadvantages===
The various disadvantages of using the primitive data types are as follows:
* Most of the object oriented programming languages do not allow the behavior or capabilities of primitive data types to be modified by programs.For example, the primitive data types in languages such as Java cannot be inherited to create further subtypes. An exception to this includes Smlltalk. It allows all data types to be extended within a program. It allows the programmer to modify the operations that can be performed on them and also to redefine the built in operations.
* Most of the object oriented languages have certain utility functions associated with non primitive data types that eases their use as compared to primitive data types that do not have such functions. This is not the case in pure objected oriented languages like Ruby, which provide a utility functions to primitive types as well.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-13T05:41:29Z

Agarg5:

''' Primitive Objects '''

== Introduction ==
Primitive datatypes are those data types that are not defined in terms of other data types[http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf]. They are basic or in-built types that a programming language provides for its users. These data types can be used for building other complex and composite data types [http://en.wikipedia.org/wiki/Primitive_data_type]. In most languages, primitive types usually consist of basic value types for representing the data to be stored. As these data types are built-in, the compilers for these languages provide more support for them by supporting most basic operations. In dynamically typed languages like Ruby, these data types are represented as objects and are referred to as primitive objects. This article discusses the various primitive data types/objects that are present in various objected oriented programming languages and their benefits.

Some of the common data types that are present in most programming languages are
*'''Integer''' - used to hold whole numbers. Can be signed or unsigned and include various types like <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>, etc.
*'''Character''' - used to hold single character, digit or symbol or a sequence of any combination of them that is stored in numeric coding. Usually stored in ASCII encoding. '
*'''Floating-point''' - used to represent real numbers with limited precision. They usually comprise of an exponent part and a fractional part. Can be signed or unsigned .
*'''Fixed-point''' - similar to floating-point, but has fixed number of digits after the decimal point [http://en.wikipedia.org/wiki/Fixed-point_arithmetic]. They are used in processors or representing base 2 and base 10 fractional values where there is no Floating point unit.
*'''Boolean''' - used to represent logical values for comparisons. Typically hold either of 2 values - true/false. Can also be represented as integers. Can be stored in a single bit, but typically stored as a byte.

== Primitive data types in C++ ==
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also allows ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

== Primitive data types in Java ==
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so. One of the major differences in Java from the other languages is that,the size of variables of these primitive types do not vary from one system to another, ie, it is not machine/architecture dependent. Also, Java does not allow numeric values to be stored unsigned[http://www.idevelopment.info/data/Programming/java/miscellaneous_java/Java_Primitive_Types.html].

Java provides wrapper classes for these primitive types and objects of those classes form primitive objects. For example, for the primitive data type ''int'', the Integer class acts as a wrapper class that provides a lot of utility methods like <code>parseInt()</code> and constants like <code>MAX_VALUE</code> and <code>MIN_VALUE</code> that can be used on an Integer object. The other wrapper classes that Java provides for these primitive classes are Integer, Double, Float, Character, Boolean, Long and Short.

int i = Integer.parseInt("50");
System.out.println(i);
System.out.println(Integer.MAX_VALUE);

Output:
50
2147483647

== Primitive data types in C# ==
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

== Primitive data types/objects in Ruby ==
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| ± 2^30 (for 32-bit systems)
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html]
| values > 2^30 (for 32-bit systems)
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308 (for 32-bit systems)
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

== Advantages and Disadvantages ==
In this section we discuss the various advantages and disadvanges of using the primitive data types over the corresponding object types.

=== Advantages ===
The various advantages of using primitive data types are as follows:
=== Ease of use ===
Using primitive data types is much more efficient way of programming than programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].
=== Simplicity ===
Working with primitive data types is more intuitive.

===Disadvantages===
The various disadvantages of using the primitive data types are as follows:
* Most of the object oriented programming languages do not allow the behavior or capabilities of primitive data types to be modified by programs.For example, the primitive data types in languages such as Java cannot be inherited to create further subtypes. An exception to this includes Smlltalk. It allows all data types to be extended within a program. It allows the programmer to modify the operations that can be performed on them and also to redefine the built in operations.
* Most of the object oriented languages have certain utility functions associated with non primitive data types that eases their use as compared to primitive data types that do not have such functions. This is not the case in pure objected oriented languages like Ruby, which provide a utility functions to primitive types as well.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-09T23:55:33Z

Agarg5: /* Advantages */

''' Primitive Objects '''

== Introduction ==
Primitive datatypes are those that are not defined in terms of other data types[http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf]. It is a basic or in-built type that a programming language provides for its users. These data types can be used for building other complex and composite data types [http://en.wikipedia.org/wiki/Primitive_data_type]. In most languages, primitive types usually consist of basic value types for representing the data to be stored. As these data types are built-in, the compilers for these languages usually provide inbuilt support for these data types and so would support most basic operations. In dynamically typed languages like Ruby, these are represented as objects and are referred to as primitive objects. This article discusses the various primitive data types/objects that are present in various objected oriented programming languages and their benefits.

Some of the common data types that are present in most programming languages are
*'''Integer''' - used to hold whole numbers. Can be signed or unsigned and include various types like <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>, etc.
*'''Character''' - used to hold single character, digit or symbol or a sequence of any combination of them that is stored in numeric coding. Usually stored in ASCII encoding. '
*'''Floating-point''' - used to represent real numbers with limited precision. They usually comprise of an exponent part and a fractional part. Can be signed or unsigned .
*'''Fixed-point''' - similar to floating-point, but has fixed number of digits after the decimal point [http://en.wikipedia.org/wiki/Fixed-point_arithmetic]. They are used in processors or representing base 2 and base 10 fractional values where there is no Floating point unit.
*'''Boolean''' - used to represent logical values used for comparisons. Typically hold either of 2 values - true/false. Can also be represented as integers. Can be stored in a single bit, but typically stored as a byte.

== Primitive data types in C++ ==
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also provides ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

== Primitive data types in Java ==
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so.

== Primitive data types in C# ==
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

== Primitive data types/objects in Ruby ==
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| ± 2^30 (for 32-bit systems)
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html]
| values > 2^30 (for 32-bit systems)
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308 (for 32-bit systems)
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

== Advantages and Disadvantages ==
In this section we discuss the various advantages and disadvanges of using the primitive data types over the corresponding object types.

=== Advantages ===
The various advantages that use of primitive data type offers are as follows:
*Ease of use: Using primitive data types is much more efficient way of programming then programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].
*Simplicity: Working with primitive data types is more intuitive.

===Disadvantages===
The various disadvantages of using the primitive data types are as follows:
* Most of the object oriented programming languages do not allow the behavior or capabilities of primitive data types to be modified by programs.For example, the primitive data types in languages such as Java cannot be inherited to create further subtypes. An exception to this includes Smlltalk. It allows all data types to be extended within a program. It allows the programmer to modify the operations that can be performed on them and also to redefine the built in operations.
* Most of the object oriented languages have certain utility functions associated with non primitive data types that eases their use as compared to primitive data types that do not have such functions. An exception to this is Ruby. It has utility functions associated with all the data types.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-09T23:48:32Z

Agarg5: /* Advantages */

''' Primitive Objects '''

== Introduction ==
Primitive datatypes are those that are not defined in terms of other data types[http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf]. It is a basic or in-built type that a programming language provides for its users. These data types can be used for building other complex and composite data types [http://en.wikipedia.org/wiki/Primitive_data_type]. In most languages, primitive types usually consist of basic value types for representing the data to be stored. As these data types are built-in, the compilers for these languages usually provide inbuilt support for these data types and so would support most basic operations. In dynamically typed languages like Ruby, these are represented as objects and are referred to as primitive objects. This article discusses the various primitive data types/objects that are present in various objected oriented programming languages and their benefits.

Some of the common data types that are present in most programming languages are
*'''Integer''' - used to hold whole numbers. Can be signed or unsigned and include various types like <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>, etc.
*'''Character''' - used to hold single character, digit or symbol or a sequence of any combination of them that is stored in numeric coding. Usually stored in ASCII encoding. '
*'''Floating-point''' - used to represent real numbers with limited precision. They usually comprise of an exponent part and a fractional part. Can be signed or unsigned .
*'''Fixed-point''' - similar to floating-point, but has fixed number of digits after the decimal point [http://en.wikipedia.org/wiki/Fixed-point_arithmetic]. They are used in processors or representing base 2 and base 10 fractional values where there is no Floating point unit.
*'''Boolean''' - used to represent logical values used for comparisons. Typically hold either of 2 values - true/false. Can also be represented as integers. Can be stored in a single bit, but typically stored as a byte.

== Primitive data types in C++ ==
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also provides ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

== Primitive data types in Java ==
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so.

== Primitive data types in C# ==
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

== Primitive data types/objects in Ruby ==
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| ± 2^30 (for 32-bit systems)
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html]
| values > 2^30 (for 32-bit systems)
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308 (for 32-bit systems)
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

== Advantages and Disadvantages ==
In this section we discuss the various advantages and disadvanges of using the primitive data types over the corresponding object types.

=== Advantages ===
The various advantages that use of primitive data type offers are as follows:
*Ease of use: Using primitive data types is much more efficient way of programming then programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].
*Simplicity: Working with primitive data types is more intuitive.
*certain functions like equality operation can be easily implemented on the primitive data types.
For example, when we use the '=='

===Disadvantages===
The various disadvantages of using the primitive data types are as follows:
* Most of the object oriented programming languages do not allow the behavior or capabilities of primitive data types to be modified by programs.For example, the primitive data types in languages such as Java cannot be inherited to create further subtypes. An exception to this includes Smlltalk. It allows all data types to be extended within a program. It allows the programmer to modify the operations that can be performed on them and also to redefine the built in operations.
* Most of the object oriented languages have certain utility functions associated with non primitive data types that eases their use as compared to primitive data types that do not have such functions. An exception to this is Ruby. It has utility functions associated with all the data types.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.
* Most of the object oriented languages have certain utility functions associated with non primitive data types that eases their use as compared to primitive data types that do not have such functions. An exception to this is Ruby. It has utility functions associated with all the data types.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-09T23:44:01Z

Agarg5: /* Disadvantages */

''' Primitive Objects '''

== Introduction ==
Primitive datatypes are those that are not defined in terms of other data types[http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf]. It is a basic or in-built type that a programming language provides for its users. These data types can be used for building other complex and composite data types [http://en.wikipedia.org/wiki/Primitive_data_type]. In most languages, primitive types usually consist of basic value types for representing the data to be stored. As these data types are built-in, the compilers for these languages usually provide inbuilt support for these data types and so would support most basic operations. In dynamically typed languages like Ruby, these are represented as objects and are referred to as primitive objects. This article discusses the various primitive data types/objects that are present in various objected oriented programming languages and their benefits.

Some of the common data types that are present in most programming languages are
*'''Integer''' - used to hold whole numbers. Can be signed or unsigned and include various types like <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>, etc.
*'''Character''' - used to hold single character, digit or symbol or a sequence of any combination of them that is stored in numeric coding. Usually stored in ASCII encoding. '
*'''Floating-point''' - used to represent real numbers with limited precision. They usually comprise of an exponent part and a fractional part. Can be signed or unsigned .
*'''Fixed-point''' - similar to floating-point, but has fixed number of digits after the decimal point [http://en.wikipedia.org/wiki/Fixed-point_arithmetic]. They are used in processors or representing base 2 and base 10 fractional values where there is no Floating point unit.
*'''Boolean''' - used to represent logical values used for comparisons. Typically hold either of 2 values - true/false. Can also be represented as integers. Can be stored in a single bit, but typically stored as a byte.

== Primitive data types in C++ ==
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also provides ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

== Primitive data types in Java ==
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so.

== Primitive data types in C# ==
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

== Primitive data types/objects in Ruby ==
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html] (for 32-bit systems)
| ± 2^30
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html] (for 32-bit systems)
| values > 2^30
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

== Advantages and Disadvantages ==
In this section we discuss the various advantages and disadvanges of using the primitive data types over the corresponding object types.

=== Advantages ===
The various advantages that use of primitive data type offers are as follows:
*Ease of use: Using primitive data types is much more efficient way of programming then programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].
*Simplicity: Working with primitive data types is more intuitive.

===Disadvantages===
The various disadvantages of using the primitive data types are as follows:
* Most of the object oriented programming languages do not allow the behavior or capabilities of primitive data types to be modified by programs.For example, the primitive data types in languages such as Java cannot be inherited to create further subtypes. An exception to this includes Smlltalk. It allows all data types to be extended within a program. It allows the programmer to modify the operations that can be performed on them and also to redefine the built in operations.
* Most of the object oriented languages have certain utility functions associated with non primitive data types that eases their use as compared to primitive data types that do not have such functions. An exception to this is Ruby. It has utility functions associated with all the data types.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.
* Most of the object oriented languages have certain utility functions associated with non primitive data types that eases their use as compared to primitive data types that do not have such functions. An exception to this is Ruby. It has utility functions associated with all the data types.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-09T23:43:14Z

Agarg5: /* Conclusion */

''' Primitive Objects '''

== Introduction ==
Primitive datatypes are those that are not defined in terms of other data types[http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf]. It is a basic or in-built type that a programming language provides for its users. These data types can be used for building other complex and composite data types [http://en.wikipedia.org/wiki/Primitive_data_type]. In most languages, primitive types usually consist of basic value types for representing the data to be stored. As these data types are built-in, the compilers for these languages usually provide inbuilt support for these data types and so would support most basic operations. In dynamically typed languages like Ruby, these are represented as objects and are referred to as primitive objects. This article discusses the various primitive data types/objects that are present in various objected oriented programming languages and their benefits.

Some of the common data types that are present in most programming languages are
*'''Integer''' - used to hold whole numbers. Can be signed or unsigned and include various types like <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>, etc.
*'''Character''' - used to hold single character, digit or symbol or a sequence of any combination of them that is stored in numeric coding. Usually stored in ASCII encoding. '
*'''Floating-point''' - used to represent real numbers with limited precision. They usually comprise of an exponent part and a fractional part. Can be signed or unsigned .
*'''Fixed-point''' - similar to floating-point, but has fixed number of digits after the decimal point [http://en.wikipedia.org/wiki/Fixed-point_arithmetic]. They are used in processors or representing base 2 and base 10 fractional values where there is no Floating point unit.
*'''Boolean''' - used to represent logical values used for comparisons. Typically hold either of 2 values - true/false. Can also be represented as integers. Can be stored in a single bit, but typically stored as a byte.

== Primitive data types in C++ ==
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also provides ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

== Primitive data types in Java ==
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so.

== Primitive data types in C# ==
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

== Primitive data types/objects in Ruby ==
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html] (for 32-bit systems)
| ± 2^30
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html] (for 32-bit systems)
| values > 2^30
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

== Advantages and Disadvantages ==
In this section we discuss the various advantages and disadvanges of using the primitive data types over the corresponding object types.

=== Advantages ===
The various advantages that use of primitive data type offers are as follows:
*Ease of use: Using primitive data types is much more efficient way of programming then programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].
*Simplicity: Working with primitive data types is more intuitive.

===Disadvantages===
The various disadvantages of using the primitive data types are as follows:
* Most of the object oriented programming languages do not allow the behavior or capabilities of primitive data types to be modified by programs.For example, the primitive data types in languages such as Java cannot be inherited to create further subtypes. An exception to this includes Smlltalk. It allows all data types to be extended within a program. It allows the programmer to modify the operations that can be performed on them and also to redefine the built in operations.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.
* Most of the object oriented languages have certain utility functions associated with non primitive data types that eases their use as compared to primitive data types that do not have such functions. An exception to this is Ruby. It has utility functions associated with all the data types.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-09T23:41:02Z

Agarg5: /* Disadvantages */

''' Primitive Objects '''

== Introduction ==
Primitive datatypes are those that are not defined in terms of other data types[http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf]. It is a basic or in-built type that a programming language provides for its users. These data types can be used for building other complex and composite data types [http://en.wikipedia.org/wiki/Primitive_data_type]. In most languages, primitive types usually consist of basic value types for representing the data to be stored. As these data types are built-in, the compilers for these languages usually provide inbuilt support for these data types and so would support most basic operations. In dynamically typed languages like Ruby, these are represented as objects and are referred to as primitive objects. This article discusses the various primitive data types/objects that are present in various objected oriented programming languages and their benefits.

Some of the common data types that are present in most programming languages are
*'''Integer''' - used to hold whole numbers. Can be signed or unsigned and include various types like <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>, etc.
*'''Character''' - used to hold single character, digit or symbol or a sequence of any combination of them that is stored in numeric coding. Usually stored in ASCII encoding. '
*'''Floating-point''' - used to represent real numbers with limited precision. They usually comprise of an exponent part and a fractional part. Can be signed or unsigned .
*'''Fixed-point''' - similar to floating-point, but has fixed number of digits after the decimal point [http://en.wikipedia.org/wiki/Fixed-point_arithmetic]. They are used in processors or representing base 2 and base 10 fractional values where there is no Floating point unit.
*'''Boolean''' - used to represent logical values used for comparisons. Typically hold either of 2 values - true/false. Can also be represented as integers. Can be stored in a single bit, but typically stored as a byte.

== Primitive data types in C++ ==
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also provides ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

== Primitive data types in Java ==
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so.

== Primitive data types in C# ==
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

== Primitive data types/objects in Ruby ==
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html] (for 32-bit systems)
| ± 2^30
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html] (for 32-bit systems)
| values > 2^30
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

== Advantages and Disadvantages ==
In this section we discuss the various advantages and disadvanges of using the primitive data types over the corresponding object types.

=== Advantages ===
The various advantages that use of primitive data type offers are as follows:
*Ease of use: Using primitive data types is much more efficient way of programming then programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].
*Simplicity: Working with primitive data types is more intuitive.

===Disadvantages===
The various disadvantages of using the primitive data types are as follows:
* Most of the object oriented programming languages do not allow the behavior or capabilities of primitive data types to be modified by programs.For example, the primitive data types in languages such as Java cannot be inherited to create further subtypes. An exception to this includes Smlltalk. It allows all data types to be extended within a program. It allows the programmer to modify the operations that can be performed on them and also to redefine the built in operations.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.

== References ==
#http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf
#http://en.wikipedia.org/wiki/Primitive_data_type
#http://en.wikipedia.org/wiki/Fixed-point_arithmetic
#http://en.wikipedia.org/wiki/C%2B%2B
#http://en.cppreference.com/w/cpp/language/types
#http://en.wikipedia.org/wiki/Wide_character
#http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx
#http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
#http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
#http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx
#http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf
#http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html
#http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html
#http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-09T23:36:55Z

Agarg5: /* Advantages */

''' Primitive Objects '''

== Introduction ==
Primitive datatypes are those that are not defined in terms of other data types[http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf]. It is a basic or in-built type that a programming language provides for its users. These data types can be used for building other complex and composite data types [http://en.wikipedia.org/wiki/Primitive_data_type]. In most languages, primitive types usually consist of basic value types for representing the data to be stored. As these data types are built-in, the compilers for these languages usually provide inbuilt support for these data types and so would support most basic operations. In dynamically typed languages like Ruby, these are represented as objects and are referred to as primitive objects. This article discusses the various primitive data types/objects that are present in various objected oriented programming languages and their benefits.

Some of the common data types that are present in most programming languages are
*'''Integer''' - used to hold whole numbers. Can be signed or unsigned and include various types like <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>, etc.
*'''Character''' - used to hold single character, digit or symbol or a sequence of any combination of them that is stored in numeric coding. Usually stored in ASCII encoding. '
*'''Floating-point''' - used to represent real numbers with limited precision. They usually comprise of an exponent part and a fractional part. Can be signed or unsigned .
*'''Fixed-point''' - similar to floating-point, but has fixed number of digits after the decimal point [http://en.wikipedia.org/wiki/Fixed-point_arithmetic]. They are used in processors or representing base 2 and base 10 fractional values where there is no Floating point unit.
*'''Boolean''' - used to represent logical values used for comparisons. Typically hold either of 2 values - true/false. Can also be represented as integers. Can be stored in a single bit, but typically stored as a byte.

== Primitive data types in C++ ==
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also provides ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

== Primitive data types in Java ==
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so.

== Primitive data types in C# ==
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

== Primitive data types/objects in Ruby ==
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html] (for 32-bit systems)
| ± 2^30
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html] (for 32-bit systems)
| values > 2^30
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

== Advantages and Disadvantages ==
In this section we discuss the various advantages and disadvanges of using the primitive data types over the corresponding object types.

=== Advantages ===
The various advantages that use of primitive data type offers are as follows:
*Ease of use: Using primitive data types is much more efficient way of programming then programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].
*Simplicity: Working with primitive data types is more intuitive.

===Disadvantages===

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.

== References ==

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-09T23:36:33Z

Agarg5: /* Advantages */

''' Primitive Objects '''

== Introduction ==
Primitive datatypes are those that are not defined in terms of other data types[http://ece.uprm.edu/~ahchinaei/courses/2010jan/icom4036/slides/11icom4036DataTypes1.pdf]. It is a basic or in-built type that a programming language provides for its users. These data types can be used for building other complex and composite data types [http://en.wikipedia.org/wiki/Primitive_data_type]. In most languages, primitive types usually consist of basic value types for representing the data to be stored. As these data types are built-in, the compilers for these languages usually provide inbuilt support for these data types and so would support most basic operations. In dynamically typed languages like Ruby, these are represented as objects and are referred to as primitive objects. This article discusses the various primitive data types/objects that are present in various objected oriented programming languages and their benefits.

Some of the common data types that are present in most programming languages are
*'''Integer''' - used to hold whole numbers. Can be signed or unsigned and include various types like <code>byte</code>, <code>short</code>, <code>int</code>, <code>long</code>, etc.
*'''Character''' - used to hold single character, digit or symbol or a sequence of any combination of them that is stored in numeric coding. Usually stored in ASCII encoding. '
*'''Floating-point''' - used to represent real numbers with limited precision. They usually comprise of an exponent part and a fractional part. Can be signed or unsigned .
*'''Fixed-point''' - similar to floating-point, but has fixed number of digits after the decimal point [http://en.wikipedia.org/wiki/Fixed-point_arithmetic]. They are used in processors or representing base 2 and base 10 fractional values where there is no Floating point unit.
*'''Boolean''' - used to represent logical values used for comparisons. Typically hold either of 2 values - true/false. Can also be represented as integers. Can be stored in a single bit, but typically stored as a byte.

== Primitive data types in C++ ==
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also provides ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

== Primitive data types in Java ==
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so.

== Primitive data types in C# ==
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

== Primitive data types/objects in Ruby ==
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html] (for 32-bit systems)
| ± 2^30
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html] (for 32-bit systems)
| values > 2^30
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

== Advantages and Disadvantages ==
In this section we discuss the various advantages and disadvanges of using the primitive data types over the corresponding object types.

=== Advantages ===
The various advantages that use of primitive data type offers are as follows:
*Ease of use: Using primitive data types is much more efficient way of programming then programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].
*Simplicity: Working with primitive data types is more intuitive.

== Conclusion ==
Primitive objects that are provided in object oriented programming languages have their own advantages and disadvantages. Though using primitive data types in most languages reduces the degree of customization possible, they provide a better performance and ease of use to compensate. The extent to which a primitive data type can be used efficiently depends on the application and the programming language used for the application.

== References ==

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-09T22:59:02Z

Agarg5: /* Advantages */

''' Primitive Objects '''

== Introduction ==
Primitive datatypes are those that are not defined in terms of other data types. It is a basic or in-built type that a programming language provides for its users. These data types can be used for building other complex and composite data types [http://en.wikipedia.org/wiki/Primitive_data_type]. In most languages, primitive types usually consist of basic value types for representing the data to be stored. As these data types are built-in, the compilers for these languages usually provide inbuilt support for these data types and so would support most basic operations. In dynamically typed languages like Ruby, these are represented as objects and are referred to as primitive objects. This article discusses the various primitive data types/objects that are present in various objected oriented programming languages and their benefits.

== Primitive data types in C++ ==
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also provides ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

== Primitive data types in Java ==
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so.

== Primitive data types in C# ==
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

== Primitive data types/objects in Ruby ==
Ruby is a multi-paradigm programming language. It is dynamically typed, and allows to be programmed procedural, object-oriented or functional[http://www.cse.iitb.ac.in/~cs701/old/beamer/Closures.pdf]. As it is also a ''pure'' object oriented programming language, even the basic inbuilt types like integer and string and even constants are represented as objects. There are a lot of inbuilt classes that are provided by Ruby[http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html]. These classes differ in some extent to their counterparts in other languages. Having all the basic types as classes allows a lot of methods to be executed on them that reduces the amount of code that needs to be newly written. Some of the basic classes are:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| Integer
| base class for FixNum and BigNum [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html]
| depends on FixNum and BigNum
|-
| FixNum
| store integer values that fit in a native machine word [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_integer.html] (for 32-bit systems)
| ± 2^30
|-
| BigNum
| store Integer values larger than FixNum[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_bignum.html] (for 32-bit systems)
| values > 2^30
|-
| String
| sequence of characters/bytes [http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_string.html]
| Does not exist.
|-
| Float
| real numbers with double precision floating point precision[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_float.html]
| ± 1.7976 * 10^308
|-
| TrueClass
| represents logical ''true'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_trueclass.html]
| true
|-
| FalseClass
| represents logical ''false'' value[http://ruby-doc.org/docs/ProgrammingRuby/html/ref_c_falseclass.html]
| false
|}

There are a various other inbuilt classes that are provided by Ruby. Those classes can be constructed by combining one or more of the above given primitive classes. As these are existing classes, there are a lot of helper methods that allow easy calculations and operations on the objects of these classes. Some of these classes also have inbuilt iterator methods that allow the values to be modified automatically for using in loops. As with many other programming languages, some of these objects take up different size (and hence range) on different architectures. These existing classes are also editable and allows to override or add new functionality to them for custom use in the application.

== Advantages and Disadvantages ==
In this section we discuss the various advantages and disadvanges of using the primitive data types over the corresponding object types.

== Advantages==
The various advantages that use of primitive data type offers are as follows:
*Ease of use: Using primitive data types is much more efficient way of programming then programming using objects. For example, in Java when we use boxing in a loop it causes certain performance issues and is inefficient compared to using the primitive types directly. For more details and a sample program see [http://today.java.net/pub/a/today/2005/03/24/autoboxing.html#performance%5Fissue].

== Conclusion ==

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-09T22:57:40Z

Agarg5: /* Advantages and Disadvantages */

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-09T21:36:32Z

Agarg5: /* Introduction */

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-09T21:27:25Z

Agarg5: /* Primitive data types in C# */

''' Primitive Objects '''

== Introduction ==
A primitive data type is a basic or in-built type that a programming language provides for its users. These data types can be used for building other complex and composite data types [http://en.wikipedia.org/wiki/Primitive_data_type]. In most languages, primitive types usually consist of basic value types for representing the data to be stored. As these data types are built-in, the compilers for these languages usually provide inbuilt support for these data types and so would support most basic operations. In dynamically typed languages like Ruby, these are represented as objects and are referred to as primitive objects. This article discusses the various primitive data types/objects that are present in various objected oriented programming languages and their benefits.

== Primitive data types in C++ ==
[http://en.wikipedia.org/wiki/C%2B%2B C++] is a statically typed, objected oriented programming language. It is widely used on a lot of hardware and software platforms. As C++ just adds object oriented features and a few other enhancements to C, the primitive data types that it provides are same as those provided by C[http://en.wikipedia.org/wiki/C%2B%2B]. They are described below [http://en.cppreference.com/w/cpp/language/types].

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Description
! Size
! Range
|-
| int
| Basic numerical data. Can have modifiers that vary size and range.
| 4 bytes
| -2,147,483,648 to 2,147,483,647
|-
| char
| Can hold one character of data like an alphabet, number, or symbol represented in ASCII
| 1 byte
| -128 to 127
|-
| wchar_t
| used for storing compiler-defined wide characters and unicode characters [http://en.wikipedia.org/wiki/Wide_character]
| compiler defined
| compiler defined
|-
| float
| single precision floating-point
| 4 bytes
| ± 3.402,823,4 * 10^38
|-
| double
| double precision floating-point
| 8 bytes
| +/–1.7 * 10^308 [http://msdn.microsoft.com/en-us/library/e02ya398(v=vs.80).aspx]
|-
| bool
| represents logical values
| 1 byte
| true/false
|-
| void
| generic identifier that does not identify type [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]
| Does not exist
| Does not exist
|}

C++ allows variables of any of these data types to be created and also supports using these data types to construct complex data types like structures and classes. C++ also provides ''pointers'' that can be used to store the address of a variable of any simple or complex data type.

== Primitive data types in Java ==
There is a certain group of data types that is used very frequently by the programmer. These types are included in the Java language as the primitive data types.These data types have a fixed size which does not change from one system to another and adds to the portability feature of java. There are 8 primitive data types defined in java which are as follows:[http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Description
! Size(in bits)
! Range
! Usage
! Default Value
|-
| byte
| Signed two's complement integer
| 8 bits
| -128 to 127
| This datatype can be used in arrays where there is a space constraint to save memory.
| 0
|-
| short
| Signed two's complement integer
| 16 bits
| -32,768 to 32,767
| This datatype can also be used to save memory in large arrrays.
| 0
|-
| int
| signed two's complement integer
| 32 bits
| -2,147,483,648 to 2,147,483,647
| This datatype is generally the default datatype for all the numbers we use in our program.
| 0
|-
| long
| signed two's complement integer
| 64 bits
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
| This type is used when we require a value that is outside the range of values provided by int.
| 0L
|-
|float
| Single-precision IEEE 754 floating point
| 32 bits
| 32-bit IEEE 754 floating-point numbers.
| Use this datatype to save memory in large arrays.
| 0.0f
|-
| double
| Double-precision 64-bit IEEE 754 floating point
| 64 bits
| 64-bit IEEE 754 floating-point numbers.
| This data type is generally the default for decimal values.
| 0.0d
|-
| boolean
| Boolean
| 1- bit
| false, true
| Use this data type for flags that track a true or false condition.
| false
|-
| char
| a char is a single 16-bit character encoded using Unicode
| 16 bit
| Unicode character \u0000(0) through unicode character \uffff(65,535)
| This type is used to define single characters.
| '\u0000'
|}
Besides these 8 primitive data types java provides support to characterstrings through Java.lang.String class. String is not a primitive datatype but its usage and functionality makes us think of it being so.

== Primitive data types in C# ==
C# is a statically-typed object oriented programming language. C# provides all the data types that are available in Java, and adds support for unsigned numerals and a new 128-bit high-precision floating-point type. All primitive data types in C# are objects in the System namespace.
The various primitive data types in C# are defined below:[http://msdn.microsoft.com/en-us/library/ms228360(v=vs.80).aspx]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
| byte
| System.Byte
| 8 bits
| 8-bit unsigned integral type.
| 0 to 255
|-
| sbyte
| System.SByte
| 8 bits
| signed two's complement integer
| -128 to 127
|-
| short
| System.Int16
| 16 bits
| 16-bit signed integral type.
| -32,768 to 32,767
|-
| ushort
| System.UInt16
| 16 bits
| 16-bit unsigned integral type.
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| System.Int32
| 32 bits
| 32-bit signed integral type.
| 0 to 4,294,967,295
|-
| long
| System.Int64
| 64 bits
| 64-bit signed integral type.
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| System.UIint64
| 64 bits
| 64-bit unsigned integral type.
| 0 to 18,446,744,073,709,551,615
|-
| float
| System.Single
| 32 bits
| Single-precision floating-point type.
| -3.402823e38 to 3.02823e38
|-
| double
| System.Double
| 64 bits
| Double-precision floating-point type.
| -1.79769313486232e308 to 1.79769313486232e308
|-
| bool
| System.Boolean
| 1 bit
| Logical Boolean type
| false, true
|-
| char
| System.Char
| 16 bits
| A 16-bit Unicode character.
| Unicode character \u0000 through unicode character \uffff
|-
| object
| System.Object
| N/A
| Ultimate base type of all other types.
| N/A
|-
| string
| System.String
| N/A
| A sequence of Unicode characters.
| N/A
|-
| decimal
| System.Decimal
| 128
| Precise decimal with 28 significant digits.
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

== Primitive data types/objects in Ruby ==

== Advantages and Disadvantages ==

== Conclusion ==

CSC/ECE 517 Fall 2011/ch3 3h rr

2012-09-09T20:58:51Z

Agarg5: /* Primitive Data Types in Java */

''3h. Primitive objects. At the beginning of Lecture 11, we discovered that Fixnums and Bignums are handled differently behind the scenes in Ruby. Other languages, like Java, have made similar distinctions. By contrast, languages such as C# and Eiffel try to hide these implementation differences from users. Answer two questions: (1) How have different o-o languages implemented primitive objects? E.g., how are they represented in memory, how are they tested for, do comparisons do anything different than for class objects, etc. (2) What are the advantages and disadvantages of treating primitives differently from class objects in source code?''

== Introduction ==
Programming languages, whether statically or dynamically typed, have support for certain in-built data types. These data types, known as primitive types, are the basic representation of information in programs and have certain fixed attributes for a specific language[http://en.wikipedia.org/wiki/Primitive_data_type]. Statically typed languages such as C++, Java, Perl etc. support primitive data types, whereas with dynamically typed languages such as Ruby, Smalltalk, Lisp etc. they are actually in the form of primitive objects. These primitive types are used to store the basic types of information that a computer can store and manipulate, and can also be used as building blocks for creating more complex data types.
This article explains the way different primitive types are implemented in certain object oriented languages. An analysis of the benefits and drawbacks of such types and the methods used to operate on them is also presented.

== Primitive Types ==
The primitive types commonly included in most programming languages are:
* Boolean
* Character
* Integer
* Floating-point number
* Fixed-point number
* Reference

=== Boolean ===
A Boolean is a primitive data type used to store one of two logical types: true or false. Boolean data types are most commonly used as input paramters to a conditional statement (such as an ‘if’ statement), or as the output of a comparison between two comparable data types. Booleans can be implemented in languages as either a discrete logical type, or implicitly as a numerical type. In many languages, booleans can be implicitly converted to and from integer types.

=== Character ===
A character is a data type that represents an element of a written language, such as a letter, number, or symbol. A character can also represent a control character, such as a carriage return or newline, which does not have a written meaning but controls how other characters are stored or displayed. Characters are commonly stored as integers, and encoded using a character map.

=== Integer ===
An integer is a data type that represents one element of a finite subset of mathematical integers. Integer, or Integral, data types can be either unsigned (able to store only positive whole numbers) or signed (able to store either positive or negative whole numbers). The range of values that can be represented by an integer depends on the number of bits used to store the integer, whether or not it is a signed integer, and the encoding scheme (if it is signed). Typically, an integer has a minimum and maximum value, and can store any integer in the range between those values. The minimum value for unsigned integers is typically 0, and the maximum value is typically determined by the amount of memory used to store the integer. For example, a un unsigned 8-bit number can store 2^8 (or 256) possible integral values; and would typically store any value from 0 to 255. More generally, an n-bit unsigned integer can store from 0 to (2^n)-1. For signed integers, modern computers use the Two’s Complement encoding scheme. This allows for a range of −2^(n−1) through 2^(n−1)−1. For example, an 8-bit signed integer could store any whole number in the range from -128 through +127.

=== Floating-Point Number ===
A floating point number is a data type used to represent real numbers in a large range with varying degrees of precision. In this representation, numbers are represented with a variable number of significant digits, and a variable number of exponential digits.

=== Fixed-Point number ===
A fixed-point number is a data type used to represent real numbers. Fixed-point numbers are called fixed-point because they have a set number of digits before and after a decimal mark. In this regard, fixed-point numbers are represented as an integer, but are scaled by a predetermined factor.

Fixed-point numbers are commonly used in microprocessors that do not have a floating-point unit, or in systems in which computational efficiency is critical. Fixed-point numbers can be treated as integers by an arithmetic logic unit (ALU) and scaled after a result is obtained, which can significantly lower the amount of time needed for a processor to obtain the result for some algorithms.

Implementing algorithms using fixed-point arithmetic requires great care, because of the potential for information loss. Fixed-point arithmetic operations -- multiplication in particular, has the potential to cause overflow. Algorithms must be written with care to ensure that each term of an equation has a similar range and that the result will not cause an overflow.

=== Reference ===

A Reference is a data type that enables a program to access another item in memory. A reference differs from other primitive data types in that it does not store data itself; instead it stores a value referring to another data object. References are commonly used to refer to objects of large non-primitive data types. References commonly store the physical memory address of the data that they are referring to. Accessing the data referred to by a Reference is called dereferencing.

== Primitive Data Types in C++ ==

C++ is a statically-typed object oriented language. C++ is based on the C programming language, which is procedural, and adds support for object-oriented code.

These data types are defined in C++: [http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php]

{| border="1" style="border-spacing: 0" cellpadding="5"
! Name
! Size
! Description
! Range
|-
| void
| N/A
| the void data type is used to explicitly identify that a data has no type
| N/A
|-
| int
| 32 bits
| simple numerical type
| See [[http://www.jk-technology.com/c/inttypes.html]]
|-
| float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 8 bits
| a char is a single 8-bit character encoded using ASCII
| Ascii character 0x00 through ascii character 0xFF
|}
C++ supports Pointers for all of the types listed in the table above, as well as more complex data types (such as structs). A Pointer in C++ is a data type that stores the physical address of some other data. Pointers are created in C++ by using the * operator. For example, a *Double[] is a pointer to an array of double-precision floating point numbers. C++ Also supports function pointers -- pointers that reference the beginning address of a function in memory. They are commonly used to implement callback functions [http://newty.de/fpt/intro.html#what]

== Primitive Data Types in Java ==

Java is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. These data types are defined in Java: [http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html]
{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"|Name
! Size
! Description
! Range
|-
|byte
|8 bits
|signed two's complement integer
|-128 to 127
|
|-
| short
|16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| int
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| long
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
|float
| 32 bits
| single-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| double
| 64 bits
| double-precision IEEE 754 floating point
| See [[http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3]]
|-
| boolean
| 1 bit
| boolean
| false, true
|-
| char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|}

Java also defines a String class, which is used to create objects of many chars. The String class provides functionality commonly implemented using arrays of chars in other languages, such as C.

Java also defines the 'unsigned' keyword, which can be used to as a modifier to any of the integral types listed in the table above. If the 'unsigned' keyword is used, the integral type will be unsigned instead of signed, and its range will change correspondingly.

Java is capable of using any two objects of the same primitive data type for comparison. Java defines a class for each data type, which have the same name but a capitalized first letter (e.g. Float instead of float). These classes, called wrapper classes provide a series of methods that can manipulate their associated primitive data type, as well as convert to and from other data types.

== Primitive Data Types in C# ==

C# is a statically-typed object oriented programming language. Primitive types are defined in the language, and conversion between them must be explicitly performed. Primitive data types are created using a keyword, which is also the name of the data type. C# has all of the data types that are available in Java, as well as some additional ones.

Similar to Java, C# defines a String class which is used to create objects of many chars. These data types are defined in C#: [http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx]

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! .NET Class
! width="50" | Size
! Description
! Range
|-
|byte
| Byte
| 8 bits
|signed two's complement integer
| -128 to 127
|-
| sbyte
| SByte
| 8 bits
| signed two's complement integer
| -0 to 255
|-
| short
| Int16
| 16 bits
| signed two's complement integer
| -32,768 to 32,767
|-
| ushort
| UInt16
| 16 bits
| unsigned integer
| 0 to 65,535
|-
| int
| Int32
| 32 bits
| signed two's complement integer
| -2,147,483,648 to 2,147,483,647
|-
| uint
| UInt32
| 32 bits
| unsigned integer
| 0 to 4,294,967,295
|-
| long
| Int64
| 64 bits
| signed two's complement integer
| -9,223,372,036,854,775,808 to 9,223,373,036,854,775,807
|-
| ulong
| UInt64
| 64 bits
| unsigned integer
| 0 to 18,446,744,073,709,551,615
|-
|float
| Float
| 32 bits
| single-precision IEEE 754 floating point
| -3.402823e38 to 3.02823e38
|-
| double
| Double
| 64 bits
| double-precision IEEE 754 floating point
| -1.79769313486232e308 to 1.79769313486232e308
|-
| boolean
| Boolean
| 1 bit
| boolean
| false, true
|-
| char
| Char
| 16 bits
| a char is a single 16-bit character encoded using Unicode
| Unicode character \u0000 through unicode character \uffff
|-
| object
| Object
| N/A
| Object is the base type of all other types
| N/A
|-
| string
| String
| N/A
| String is the base type for a sequence of chars
| N/A
|-
| decimal
| Decimal
| 128
| Decimal is an integral type that can represent a decimal number with 29 significant digits
| ±1.0 × 10e−28 to ±7.9 × 10e28
|}

Like Java, each primitive data type in C# also has a class associated with it that. These classes serve a similar purpose to their associated ones in Java. They are used for comparison of objects, as well as conversion between other similar types.

== Primitive Objects in Ruby ==
Ruby is a pure object oriented language as compared to languages such as Java or C#, which use a more hybrid approach. In Ruby, all data types are represented as Objects. There are some [http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html inbuilt classes] that are provided to users in Ruby. However, only some of them are a basic building block for forming other types. This subset shown below gives us a list of primitive objects that can be used for data representation and manipulation:

{| border="1" style="border-spacing: 0" cellpadding="5"
! align="left"| Name
! Description
! Range
|-
| TrueClass
| Singleton instance "true" allowed
| true
|-
| FalseClass
| Singleton instance "false" allowed
| false
|-
| Integer [http://www.ruby-doc.org/core/Integer.html]
| Abstract class that forms the basis for Fixnum and Bignum
| See Fixnum and Bignum
|-
| Fixnum [http://www.ruby-doc.org/core-1.8.7/Fixnum.html]
| Integer representations that fit in native machine word
| Machine architecture dependent. 2^30-1 to -2^30 on 32-bit machines.
|-
| Bignum [http://www.ruby-doc.org/core/Bignum.html]
| Integer representations that do not fit in Fixnum width
| Machine architecture dependent. Values above Fixnum range.
|-
| Float [http://www.ruby-doc.org/core/Float.html]
| Real numbers using double precision representation
| Value after decimal point can be formatted
|-
| String [http://corelib.rubyonrails.org/classes/String.html]
| Contains sequence of characters
| No physical limit, but can be decided by machine architecture
|}

One interesting observation from the above table is that Ruby does not have a Boolean class; instead it has a separate TrueClass and FalseClass [http://www.skorks.com/2009/09/true-false-and-nil-objects-in-ruby].

puts true.class
=> TrueClass
puts false.class
=> FalseClass

Although types such as Array, Hash are also in-built types, they can be further composed of elements that are internally represented in one of the primitive types. Hence, they will not be treated by us as primitive objects, in the traditional definition of the term.
Each of the primitive objects listed above also provide certain convenience methods that are applicable for the underlying type.
For example, the Fixnum, Bignum and Float types provide support for arithmetic operations such as addition (+), subtraction(--), multiplication(*) and so on.
As with all other classes in Ruby, users can add functionality to existing primitive objects by reopening classes. The amount of memory required to implement the primitive objects in Ruby is machine dependent in some cases.

== Merit Analysis of Primitive Types ==
This section deals with a brief analysis of the relative merits and demerits of primitive data types. While we focus on Java or Ruby for this purpose, most of these points are applicable across all object oriented languages.

=== Advantages ===
Primitive types in object oriented languages have certain advantages over their class object counterparts.
* Simplicity: Primitive types/objects provide users a simple mechanism of manipulating data without relying on additional objects to achieve the same functionality. Operations on primitive types are more intuitive.
* Efficiency: This statement is applicable if the underlying primitive object definition is not modified (a feature that languages such as Ruby provide to users). As the representation in memory is designed to be make most efficient use of the underlying datatype, use of primitives can provide a benefit to the user, over the use of class objects to store the same data.
Eg. Java provides wrappers [http://www.glenmccl.com/tip_016.htm] for certain primitive types. There is a certain performance and space cost associated with these.
So, to maximize efficiency, direct use of the primitive types would provide the most benefit.
* Ability to use inbuilt methods: Depending on the primitive type, languages such as Ruby provide methods that can be used specifically to probe or manipulate objects.
Eg. [http://corelib.rubyonrails.org/classes/String.html String] primitive object provides convenience methods such as upcase to convert the entire string to upper case, or capitalize, which converts only the first character to upper case.
* Ease of testing for comparison: With primitive types, the equality testing operators such as == can be used. These essentially compare the values stored in the primitive types. Regular objects also offer the eql? method for testing equality. However, the following are not equivalent:
a=10
=> 10
a==10
=> true
a==10.0
=> true
a.eql?(10.0)
=> false
The reason the .eql? fails is that this operator tests for value and type being the same. 10 is type Fixnum and 10.0 is type Float.
The eql? can be overridden by == for primitive objects if you wish to compare only the values, but that can have a negative impact on performance [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html].

=== Disadvantages ===
* Lack of inheritance capability: The primitive data types in languages such as Java cannot be inherited to create further subtypes.
* Unexpected results due to method overriding: There are certain examples such as [http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html], which show that overriding inbuilt methods such as == and eql? can lead to unexpected results.

== Conclusion ==
Object oriented languages have varying levels of support for primitive data types and objects. Whether they are beneficial or not depends on the application to a great deal. If handled correctly, they can make object oriented programs more efficient. However, the user needs to be aware of the underlying representation of these types to handle any unexpected results.

== References ==
# http://en.wikipedia.org/wiki/Primitive_data_type
# http://sparkcharts.sparknotes.com/cs/cplusplus/section2.php
# http://www.jk-technology.com/c/inttypes.html
# http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
# http://newty.de/fpt/intro.html
# http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
# http://msdn.microsoft.com/en-us/library/ms228360%28v=vs.80%29.aspx
# http://ruby-doc.org/docs/ProgrammingRuby/html/builtins.html
# http://blog.vishnuiyengar.com/2009/09/primitive-obsession-in-ruby-aka-not.html
# http://www.glenmccl.com/tip_016.htm
# http://www.skorks.com/2009/09/ruby-equality-and-object-comparison/

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-09T20:52:24Z

Agarg5: /* Primitive data types in Java */

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-09T20:50:04Z

Agarg5: /* Primitive data types in Java */

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-09T20:42:49Z

Agarg5: /* Primitive data types in Java */

CSC/ECE 517 Fall 2012/ch1 1w21 aa

2012-09-09T20:42:09Z

Agarg5: /* Primitive data types in Java */