Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T05:01:31Z

Grepper: /* Hungarian */

'''Variable Naming Conventions'''

As a popular saying goes, source code is meant to be read by humans; it is only a coincidence that it is also interpreted by machines. Holding the data for source code, variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''||

==Popular Naming Conventions==

To establish consistency, several conventions have been popularized to give programmers a method for writing variable names. For example, since in most programming languages white space is considered a delimiter for token parsing, one has to establish a non-whitespace system for separating two adjacent words for one variable. If one wants to reference a "First Name" data string, there are many different ways we could establish a variable name for this.

===Camel Case===
The format for Camel Case is to start the variable name off with a valid, lowercase letter, and then for each word afterwards, capitalize its first letter. This allows each word to be easily distinguished without injecting any unnatural characters into the variable name. For our "First Name" example, we would reference this as <code>firstName</code>.

===Hungarian===
[http://en.wikipedia.org/wiki/Hungarian_notation Hungarian notation] is a naming convention that was intended to be used in any language. There are two types of this notation, Systems and Apps. Systems notation requires the variable to be prefixed by the data type of the variable's use. For example, a float number that is used to hold the value of the circumference of a sprocket would be defined as fSprocketCircumference. Apps notation requires the purpose of the variable it's prefix. Using the previous example, the Apps definition would be numSprocketCircumference.

In reference to our "First Name" example, notice how we wish to elaborate that this variable will hold a string. A candidate Hungarian convention variable name could be <code>strFirstName</code>.

===Universally Used Variables===
There are commonly used variables that programmers use no matter what language he/she is coding in. The following list does not constitute acceptance of the variables as properly named. The most common are:
* i, j, k - used for counting especially in short code snippets
* x, y, z - used for holding the position of an object
* file - to indicate a placeholder for the location of a file
* dir - holds the string of a folder in a file system
* e - holds the value of the system error

===Special Variable Conventions===

<hr/>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )

* Don't use needless variables, eg.
** <code>FOURTY_TWO = 42;</code>
** <code>x = 4; one_more_than_x = x + 1</code>

* Don't give up!

== Questions to Ask ==

* Will my variable names by understood?
* Will they provide information to the maintenance programmer?
* Will they be easy to get right as more code is written?
* Will they get confused with one another?

(Source http://www.wellho.net/solutions/general-what-makes-a-good-variable-name.html )

==The Good and The Bad==

Now that you have the basic tools an example that shows three types of naming, bad, okay, and good is used to help pull all of the information that has been given to this point.

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T04:56:29Z

Grepper:

'''Variable Naming Conventions'''

As a popular saying goes, source code is meant to be read by humans; it is only a coincidence that it is also interpreted by machines. Holding the data for source code, variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Popular Naming Conventions==

To establish consistency, several conventions have been popularized to give programmers a method for writing variable names. For example, since in most programming languages white space is considered a delimiter for token parsing, one has to establish a non-whitespace system for separating two adjacent words for one variable. If one wants to reference a "First Name" data string, there are many different ways we could establish a variable name for this.

===Camel Case===
The format for Camel Case is to start the variable name off with a valid, lowercase letter, and then for each word afterwards, capitalize its first letter. This allows each word to be easily distinguished without injecting any unnatural characters into the variable name. For our "First Name" example, we would reference this as <code>firstName</code>.

===Hungarian===
[http://en.wikipedia.org/wiki/Hungarian_notation Hungarian notation] is a naming convention that was intended to be used in any language. There are two types of this notation, Systems and Apps. Systems notation requires the variable to be prefixed by the data type of the variable's use. For example, a float number that is used to hold the value of the circumference of a sprocket would be defined as fSprocketCircumference. Apps notation requires the purpose of the variable it's prefix. Using the previous example, the Apps definition would be numSprocketCircumference.

===Universally Used Variables===
There are commonly used variables that programmers use no matter what language he/she is coding in. The following list does not constitute acceptance of the variables as properly named. The most common are:
* i, j, k - used for counting especially in short code snippets
* x, y, z - used for holding the position of an object
* file - to indicate a placeholder for the location of a file
* dir - holds the string of a folder in a file system
* e - holds the value of the system error

===Special Variable Conventions===

<hr/>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )

* Don't use needless variables, eg.
** <code>FOURTY_TWO = 42;</code>
** <code>x = 4; one_more_than_x = x + 1</code>

* Don't give up!

== Questions to Ask ==

* Will my variable names by understood?
* Will they provide information to the maintenance programmer?
* Will they be easy to get right as more code is written?
* Will they get confused with one another?

(Source http://www.wellho.net/solutions/general-what-makes-a-good-variable-name.html )

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T04:53:20Z

Grepper: /* Popular Naming Conventions */

'''Variable Naming Conventions'''

As a popular saying goes, source code is meant to be read by humans; it is only a coincidence that it is also interpreted by machines. Holding the data for source code, variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Popular Naming Conventions==

To establish consistency, several conventions have been popularized to give programmers a method for writing variable names. For example, since in most programming languages white space is considered a delimiter for token parsing, one has to establish a non-whitespace system for separating two adjacent words for one variable. If one wants to reference a "First Name" data string, there are many different ways we could establish a variable name for this.

===Hungarian===
[http://en.wikipedia.org/wiki/Hungarian_notation Hungarian notation] is a naming convention that was intended to be used in any language. There are two types of this notation, Systems and Apps. Systems notation requires the variable to be prefixed by the data type of the variable's use. For example, a float number that is used to hold the value of the circumference of a sprocket would be defined as fSprocketCircumference. Apps notation requires the purpose of the variable it's prefix. Using the previous example, the Apps definition would be numSprocketCircumference.

===Universally Used Variables===
There are commonly used variables that programmers use no matter what language he/she is coding in. The following list does not constitute acceptance of the variables as properly named. The most common are:
* i, j, k - used for counting especially in short code snippets
* x, y, z - used for holding the position of an object
* file - to indicate a placeholder for the location of a file
* dir - holds the string of a folder in a file system
* e - holds the value of the system error

===Special Variable Conventions===

<hr/>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )

* Don't use needless variables, eg.
** <code>FOURTY_TWO = 42;</code>
** <code>x = 4; one_more_than_x = x + 1</code>

* Don't give up!

== Questions to Ask ==

* Will my variable names by understood?
* Will they provide information to the maintenance programmer?
* Will they be easy to get right as more code is written?
* Will they get confused with one another?

(Source http://www.wellho.net/solutions/general-what-makes-a-good-variable-name.html )

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T04:53:01Z

Grepper: /* Popular Naming Conventions */

'''Variable Naming Conventions'''

As a popular saying goes, source code is meant to be read by humans; it is only a coincidence that it is also interpreted by machines. Holding the data for source code, variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Popular Naming Conventions==

To establish consistency, several conventions have been popularized to give programmers a method for writing variable names. For example, since in most programming languages white space is considered a delimiter for token parsing, one has to establish a system for separating two adjacent words for one variable. If one wants to reference a "First Name" data string, there are many different ways we could establish a variable name for this.

===Hungarian===
[http://en.wikipedia.org/wiki/Hungarian_notation Hungarian notation] is a naming convention that was intended to be used in any language. There are two types of this notation, Systems and Apps. Systems notation requires the variable to be prefixed by the data type of the variable's use. For example, a float number that is used to hold the value of the circumference of a sprocket would be defined as fSprocketCircumference. Apps notation requires the purpose of the variable it's prefix. Using the previous example, the Apps definition would be numSprocketCircumference.

===Universally Used Variables===
There are commonly used variables that programmers use no matter what language he/she is coding in. The following list does not constitute acceptance of the variables as properly named. The most common are:
* i, j, k - used for counting especially in short code snippets
* x, y, z - used for holding the position of an object
* file - to indicate a placeholder for the location of a file
* dir - holds the string of a folder in a file system
* e - holds the value of the system error

===Special Variable Conventions===

<hr/>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )

* Don't use needless variables, eg.
** <code>FOURTY_TWO = 42;</code>
** <code>x = 4; one_more_than_x = x + 1</code>

* Don't give up!

== Questions to Ask ==

* Will my variable names by understood?
* Will they provide information to the maintenance programmer?
* Will they be easy to get right as more code is written?
* Will they get confused with one another?

(Source http://www.wellho.net/solutions/general-what-makes-a-good-variable-name.html )

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T04:52:41Z

Grepper: /* Popular Naming Conventions */

'''Variable Naming Conventions'''

As a popular saying goes, source code is meant to be read by humans; it is only a coincidence that it is also interpreted by machines. Holding the data for source code, variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Popular Naming Conventions==

To establish consistency, several conventions have been established to give programmers a method for writing variable names. For example, since in most programming languages white space is considered a delimiter for token parsing, one has to establish a system for separating two adjacent words for one variable. If one wants to reference a "First Name" data string, there are many different ways we could establish a variable name for this.

===Hungarian===
[http://en.wikipedia.org/wiki/Hungarian_notation Hungarian notation] is a naming convention that was intended to be used in any language. There are two types of this notation, Systems and Apps. Systems notation requires the variable to be prefixed by the data type of the variable's use. For example, a float number that is used to hold the value of the circumference of a sprocket would be defined as fSprocketCircumference. Apps notation requires the purpose of the variable it's prefix. Using the previous example, the Apps definition would be numSprocketCircumference.

===Universally Used Variables===
There are commonly used variables that programmers use no matter what language he/she is coding in. The following list does not constitute acceptance of the variables as properly named. The most common are:
* i, j, k - used for counting especially in short code snippets
* x, y, z - used for holding the position of an object
* file - to indicate a placeholder for the location of a file
* dir - holds the string of a folder in a file system
* e - holds the value of the system error

===Special Variable Conventions===

<hr/>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )

* Don't use needless variables, eg.
** <code>FOURTY_TWO = 42;</code>
** <code>x = 4; one_more_than_x = x + 1</code>

* Don't give up!

== Questions to Ask ==

* Will my variable names by understood?
* Will they provide information to the maintenance programmer?
* Will they be easy to get right as more code is written?
* Will they get confused with one another?

(Source http://www.wellho.net/solutions/general-what-makes-a-good-variable-name.html )

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T04:46:15Z

Grepper:

'''Variable Naming Conventions'''

As a popular saying goes, source code is meant to be read by humans; it is only a coincidence that it is also interpreted by machines. Holding the data for source code, variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Popular Naming Conventions==
===Hungarian===
[http://en.wikipedia.org/wiki/Hungarian_notation Hungarian notation] is a naming convention that was intended to be used in any language. There are two types of this notation, Systems and Apps. Systems notation requires the variable to be prefixed by the data type of the variable's use. For example, a float number that is used to hold the value of the circumference of a sprocket would be defined as fSprocketCircumference. Apps notation requires the purpose of the variable it's prefix. Using the previous example, the Apps definition would be numSprocketCircumference.

===Universally Used Variables===
There are commonly used variables that programmers use no matter what language he/she is coding in. The following list does not constitute acceptance of the variables as properly named. The most common are:
* i, j, k - used for counting especially in short code snippets
* x, y, z - used for holding the position of an object
* file - to indicate a placeholder for the location of a file
* dir - holds the string of a folder in a file system
* e - holds the value of the system error

===Special Variable Conventions===

<hr/>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )

* Don't use needless variables, eg.
** <code>FOURTY_TWO = 42;</code>
** <code>x = 4; one_more_than_x = x + 1</code>

* Don't give up!

== Questions to Ask ==

* Will my variable names by understood?
* Will they provide information to the maintenance programmer?
* Will they be easy to get right as more code is written?
* Will they get confused with one another?

(Source http://www.wellho.net/solutions/general-what-makes-a-good-variable-name.html )

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T04:41:42Z

Grepper: /* Dos And Don'ts */

'''Variable Naming Conventions'''

As a popular saying goes, source code is meant to be read by humans; it is only a coincidence that it is also interpreted by machines. Holding the data for source code, variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )

* Don't use needless variables, eg.
** <code>FOURTY_TWO = 42;</code>
** <code>x = 4; one_more_than_x = x + 1</code>

* Don't give up!

== Questions to Ask ==

* Will my variable names by understood?
* Will they provide information to the maintenance programmer?
* Will they be easy to get right as more code is written?
* Will they get confused with one another?

(Source http://www.wellho.net/solutions/general-what-makes-a-good-variable-name.html )

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T04:41:29Z

Grepper: /* Dos And Don'ts */

'''Variable Naming Conventions'''

As a popular saying goes, source code is meant to be read by humans; it is only a coincidence that it is also interpreted by machines. Holding the data for source code, variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )

* Don't use needless variables, eg.
** <code>FOURTY_TWO = 42;</code>
** <code>x = 4; one_more_than_x = x + 1</code>

* Don't give up!

== Questions to Ask ==

* Will my variable names by understood?
* Will they provide information to the maintenance programmer?
* Will they be easy to get right as more code is written?
* Will they get confused with one another?

(Source http://www.wellho.net/solutions/general-what-makes-a-good-variable-name.html )

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T04:22:32Z

Grepper:

'''Variable Naming Conventions'''

As a popular saying goes, source code is meant to be read by humans; it is only a coincidence that it is also interpreted by machines. Holding the data for source code, variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )
* Don't give up!

== Questions to Ask ==

* Will my variable names by understood?
* Will they provide information to the maintenance programmer?
* Will they be easy to get right as more code is written?
* Will they get confused with one another?

(Source http://www.wellho.net/solutions/general-what-makes-a-good-variable-name.html )

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T04:17:45Z

Grepper:

'''Variable Naming Conventions'''

As a popular saying goes, source code is meant to be read by humans; it is only a coincident that it is also interpreted by machines. Holding the data for source code, variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )
* Don't give up!

== Questions to Ask ==

* Will my variable names by understood?
* Will they provide information to the maintenance programmer?
* Will they be easy to get right as more code is written?
* Will they get confused with one another?

(Source http://www.wellho.net/solutions/general-what-makes-a-good-variable-name.html )

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T04:17:17Z

Grepper:

'''Variable Naming Conventions'''

As a popular saying goes, source code is meant to be read by humans; it is only a coincident that it is also interpreted by machines. Providing the data for source code, variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )
* Don't give up!

== Questions to Ask ==

* Will my variable names by understood?
* Will they provide information to the maintenance programmer?
* Will they be easy to get right as more code is written?
* Will they get confused with one another?

(Source http://www.wellho.net/solutions/general-what-makes-a-good-variable-name.html )

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T04:16:10Z

Grepper:

'''Variable Naming Conventions'''

As a popular saying goes, source code is meant to be read by humans; it is only a coincident that it is also interpreted by machines. Variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )
* Don't give up!

== Questions to Ask ==

* Will my variable names by understood?
* Will they provide information to the maintenance programmer?
* Will they be easy to get right as more code is written?
* Will they get confused with one another?

(Source http://www.wellho.net/solutions/general-what-makes-a-good-variable-name.html )

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T04:04:51Z

Grepper: /* Questions to Ask */

'''Variable Naming Conventions'''

Variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )
* Don't give up!

== Questions to Ask ==

* Will my variable names by understood?
* Will they provide information to the maintenance programmer?
* Will they be easy to get right as more code is written?
* Will they get confused with one another?

(Source http://www.wellho.net/solutions/general-what-makes-a-good-variable-name.html )

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T04:04:17Z

Grepper:

'''Variable Naming Conventions'''

Variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )
* Don't give up!

== Questions to Ask ==

* Will my variable names by understood
* Will they provide information to the maintenance programmer
* Will they be easy to get right as more code is written
* Will they get confused with one another

(Source http://www.wellho.net/solutions/general-what-makes-a-good-variable-name.html )

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T03:54:44Z

Grepper:

'''Variable Naming Conventions'''

Variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )
* Don't give up!

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T03:49:53Z

Grepper: /* Dos And Don'ts */

'''Variable Naming Conventions'''

Variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

===Language Specific Conventions===
||This is our second subtopic||

====Ruby====
[http://www.ruby-lang.org/en/ Ruby] does not offer many suggestions for naming variables. What it does offer is how certain variables must begin. A normal variable is any concatenation of letter or number as long as a letter or underscore '_' is used at the beginning. An [http://en.wikipedia.org/wiki/Instance_variable instance variable], which occurs in a class as multiple copies, begins with '@'. A [http://en.wikipedia.org/wiki/Class_variable class variable] only has one copy used for all instances of a class, begins with '@@'. A [http://en.wikipedia.org/wiki/Global_variable global variable], which can be used from anywhere within the program, begins with '$'.

====Java====

====C/C++/C#====

====.NET====

==Quick Access Table==
<table>
<tr>
<th>Type</th>
<th>Hungarian</th>
<th>Ruby</th>
<th>Java</th>
<th>C</th>
<th>.NET</th>
</tr>
<tr>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
</tr>
<tr>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
</tr>
</table>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )
* Don't give up!

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T03:49:45Z

Grepper: /* Dos And Don'ts */

'''Variable Naming Conventions'''

Variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

===Language Specific Conventions===
||This is our second subtopic||

====Ruby====
[http://www.ruby-lang.org/en/ Ruby] does not offer many suggestions for naming variables. What it does offer is how certain variables must begin. A normal variable is any concatenation of letter or number as long as a letter or underscore '_' is used at the beginning. An [http://en.wikipedia.org/wiki/Instance_variable instance variable], which occurs in a class as multiple copies, begins with '@'. A [http://en.wikipedia.org/wiki/Class_variable class variable] only has one copy used for all instances of a class, begins with '@@'. A [http://en.wikipedia.org/wiki/Global_variable global variable], which can be used from anywhere within the program, begins with '$'.

====Java====

====C/C++/C#====

====.NET====

==Quick Access Table==
<table>
<tr>
<th>Type</th>
<th>Hungarian</th>
<th>Ruby</th>
<th>Java</th>
<th>C</th>
<th>.NET</th>
</tr>
<tr>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
</tr>
<tr>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
</tr>
</table>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )
* Don't give up!

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T03:49:33Z

Grepper: /* Dos And Don'ts */

'''Variable Naming Conventions'''

Variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

===Language Specific Conventions===
||This is our second subtopic||

====Ruby====
[http://www.ruby-lang.org/en/ Ruby] does not offer many suggestions for naming variables. What it does offer is how certain variables must begin. A normal variable is any concatenation of letter or number as long as a letter or underscore '_' is used at the beginning. An [http://en.wikipedia.org/wiki/Instance_variable instance variable], which occurs in a class as multiple copies, begins with '@'. A [http://en.wikipedia.org/wiki/Class_variable class variable] only has one copy used for all instances of a class, begins with '@@'. A [http://en.wikipedia.org/wiki/Global_variable global variable], which can be used from anywhere within the program, begins with '$'.

====Java====

====C/C++/C#====

====.NET====

==Quick Access Table==
<table>
<tr>
<th>Type</th>
<th>Hungarian</th>
<th>Ruby</th>
<th>Java</th>
<th>C</th>
<th>.NET</th>
</tr>
<tr>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
</tr>
<tr>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
</tr>
</table>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

 

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )
* Don't give up!

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T03:48:31Z

Grepper: /* Dos And Don'ts */

'''Variable Naming Conventions'''

Variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

===Language Specific Conventions===
||This is our second subtopic||

====Ruby====
[http://www.ruby-lang.org/en/ Ruby] does not offer many suggestions for naming variables. What it does offer is how certain variables must begin. A normal variable is any concatenation of letter or number as long as a letter or underscore '_' is used at the beginning. An [http://en.wikipedia.org/wiki/Instance_variable instance variable], which occurs in a class as multiple copies, begins with '@'. A [http://en.wikipedia.org/wiki/Class_variable class variable] only has one copy used for all instances of a class, begins with '@@'. A [http://en.wikipedia.org/wiki/Global_variable global variable], which can be used from anywhere within the program, begins with '$'.

====Java====

====C/C++/C#====

====.NET====

==Quick Access Table==
<table>
<tr>
<th>Type</th>
<th>Hungarian</th>
<th>Ruby</th>
<th>Java</th>
<th>C</th>
<th>.NET</th>
</tr>
<tr>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
</tr>
<tr>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
</tr>
</table>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )
* Don't give up!

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T03:46:56Z

Grepper: /* Dos And Don'ts */

'''Variable Naming Conventions'''

Variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

===Language Specific Conventions===
||This is our second subtopic||

====Ruby====
[http://www.ruby-lang.org/en/ Ruby] does not offer many suggestions for naming variables. What it does offer is how certain variables must begin. A normal variable is any concatenation of letter or number as long as a letter or underscore '_' is used at the beginning. An [http://en.wikipedia.org/wiki/Instance_variable instance variable], which occurs in a class as multiple copies, begins with '@'. A [http://en.wikipedia.org/wiki/Class_variable class variable] only has one copy used for all instances of a class, begins with '@@'. A [http://en.wikipedia.org/wiki/Global_variable global variable], which can be used from anywhere within the program, begins with '$'.

====Java====

====C/C++/C#====

====.NET====

==Quick Access Table==
<table>
<tr>
<th>Type</th>
<th>Hungarian</th>
<th>Ruby</th>
<th>Java</th>
<th>C</th>
<th>.NET</th>
</tr>
<tr>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
</tr>
<tr>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
</tr>
</table>

== Dos And Don'ts ==

When picking your variable names, here are a few '''Do''' and '''Don'ts''' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )
* Don't give up!

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T03:46:32Z

Grepper:

'''Variable Naming Conventions'''

Variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

===Language Specific Conventions===
||This is our second subtopic||

====Ruby====
[http://www.ruby-lang.org/en/ Ruby] does not offer many suggestions for naming variables. What it does offer is how certain variables must begin. A normal variable is any concatenation of letter or number as long as a letter or underscore '_' is used at the beginning. An [http://en.wikipedia.org/wiki/Instance_variable instance variable], which occurs in a class as multiple copies, begins with '@'. A [http://en.wikipedia.org/wiki/Class_variable class variable] only has one copy used for all instances of a class, begins with '@@'. A [http://en.wikipedia.org/wiki/Global_variable global variable], which can be used from anywhere within the program, begins with '$'.

====Java====

====C/C++/C#====

====.NET====

==Quick Access Table==
<table>
<tr>
<th>Type</th>
<th>Hungarian</th>
<th>Ruby</th>
<th>Java</th>
<th>C</th>
<th>.NET</th>
</tr>
<tr>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
</tr>
<tr>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
</tr>
</table>

== Dos And Don'ts ==

When picking your variable names, here are a few ''Do'' and ''Don'ts'' to consider.

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )
* Don't give up!

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T03:44:35Z

Grepper:

'''Variable Naming Conventions'''

Variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

===Language Specific Conventions===
||This is our second subtopic||

====Ruby====
[http://www.ruby-lang.org/en/ Ruby] does not offer many suggestions for naming variables. What it does offer is how certain variables must begin. A normal variable is any concatenation of letter or number as long as a letter or underscore '_' is used at the beginning. An [http://en.wikipedia.org/wiki/Instance_variable instance variable], which occurs in a class as multiple copies, begins with '@'. A [http://en.wikipedia.org/wiki/Class_variable class variable] only has one copy used for all instances of a class, begins with '@@'. A [http://en.wikipedia.org/wiki/Global_variable global variable], which can be used from anywhere within the program, begins with '$'.

====Java====

====C/C++/C#====

====.NET====

==Quick Access Table==
<table>
<tr>
<th>Type</th>
<th>Hungarian</th>
<th>Ruby</th>
<th>Java</th>
<th>C</th>
<th>.NET</th>
</tr>
<tr>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
</tr>
<tr>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
</tr>
</table>

== Dos And Don'ts ==

* Do use meaningful words
* Do use intention-revealing names (p 84 java book)
* Do be descriptive
* Do keep consistent in your naming convention

* Don't ever name your variables, "data" ( http://www.oreillynet.com/onlamp/blog/2004/03/the_worlds_two_worst_variable.html )
* Don't give up!

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T03:30:46Z

Grepper: /* Introduction */

'''Variable Naming Conventions'''

Variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" might be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

===Language Specific Conventions===
||This is our second subtopic||

====Ruby====
[http://www.ruby-lang.org/en/ Ruby] does not offer many suggestions for naming variables. What it does offer is how certain variables must begin. A normal variable is any concatenation of letter or number as long as a letter or underscore '_' is used at the beginning. An [http://en.wikipedia.org/wiki/Instance_variable instance variable], which occurs in a class as multiple copies, begins with '@'. A [http://en.wikipedia.org/wiki/Class_variable class variable] only has one copy used for all instances of a class, begins with '@@'. A [http://en.wikipedia.org/wiki/Global_variable global variable], which can be used from anywhere within the program, begins with '$'.

====Java====

====C/C++/C#====

====.NET====

==Quick Access Table==
<table>
<tr>
<th>Type</th>
<th>Hungarian</th>
<th>Ruby</th>
<th>Java</th>
<th>C</th>
<th>.NET</th>
</tr>
<tr>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
</tr>
<tr>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
</tr>
</table>

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T03:29:50Z

Grepper:

'''Variable Naming Conventions'''

Variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer choose good variable names and convention-styles for when writing their code.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" would be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

===Language Specific Conventions===
||This is our second subtopic||

====Ruby====
[http://www.ruby-lang.org/en/ Ruby] does not offer many suggestions for naming variables. What it does offer is how certain variables must begin. A normal variable is any concatenation of letter or number as long as a letter or underscore '_' is used at the beginning. An [http://en.wikipedia.org/wiki/Instance_variable instance variable], which occurs in a class as multiple copies, begins with '@'. A [http://en.wikipedia.org/wiki/Class_variable class variable] only has one copy used for all instances of a class, begins with '@@'. A [http://en.wikipedia.org/wiki/Global_variable global variable], which can be used from anywhere within the program, begins with '$'.

====Java====

====C/C++/C#====

====.NET====

==Quick Access Table==
<table>
<tr>
<th>Type</th>
<th>Hungarian</th>
<th>Ruby</th>
<th>Java</th>
<th>C</th>
<th>.NET</th>
</tr>
<tr>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
</tr>
<tr>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
</tr>
</table>

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T02:47:09Z

Grepper: /* The Good and The Bad */

'''Variable Naming Conventions'''

Variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer determine variable names for different programming languages and purposes.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" would be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

===Language Specific Conventions===
||This is our second subtopic||

====Ruby====

====Java====

====C/C++/C#====

====.NET====

==Quick Access Table==
<table>
<tr>
<th>Type</th>
<th>Hungarian</th>
<th>Ruby</th>
<th>Java</th>
<th>C</th>
<th>.NET</th>
</tr>
<tr>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
</tr>
<tr>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
</tr>
</table>

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T02:46:51Z

Grepper: /* The Good and The Bad */

'''Variable Naming Conventions'''

Variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer determine variable names for different programming languages and purposes.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" would be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using really short variable names, can be difficult to understand.

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

Finally, here is the same algorithm, with the original variable names from the [http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm#Pseudocode | source-example] (include reference number here).

1 '''function''' mystery_function(''Graph'', ''source''):
2 '''for each''' vertex ''v'' in ''Graph'':
3 dist[''v''] := infinity ;
4 previous[''v''] := undefined ;
5 '''end for ''';
6 dist[''source''] := 0 ;
7 ''Q'' := the set of all nodes in ''Graph'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest dist[] ;
10 '''if''' dist[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''alt'' := dist[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''alt'' < dist[''v'']:
17 dist[''v''] := ''alt'' ;
18 previous[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' dist[] ;
23 '''end''' mystery_function.

So finally, with meaningful variable names in place, it is much easier to understand the purpose of the code. In fact, many may recognize it as Dijkstra's algorithm. Comparing this well-named example to our first example shows just how important naming can be when writing code.

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

===Language Specific Conventions===
||This is our second subtopic||

====Ruby====

====Java====

====C/C++/C#====

====.NET====

==Quick Access Table==
<table>
<tr>
<th>Type</th>
<th>Hungarian</th>
<th>Ruby</th>
<th>Java</th>
<th>C</th>
<th>.NET</th>
</tr>
<tr>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
</tr>
<tr>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
</tr>
</table>

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T02:40:17Z

Grepper: /* The Good and The Bad */

'''Variable Naming Conventions'''

Variables are used in all computer programming languages and are used for various reasons; such as, holding the value of a constant, holding the value of something used many times throughout the program, or used briefly for counting. The names used for each variable are more difficult to choose than simply making any word or word combination. The rest of this article is dedicated to helping the novice programmer determine variable names for different programming languages and purposes.

==Introduction==
A [http://en.wikipedia.org/wiki/Variable_%28programming%29 Variable] is a name used within a program that holds the value of something that is known or unknown. For example, the variable "firstName" would be used to hold the string of letters that comprises a person's first name. The variable may not be set at the beginning of the program and it may change multiple times after being set. [http://en.wikipedia.org/wiki/Naming_convention_%28programming%29 Naming conventions] are a set of rules used to guide the programmer when creating the names of variables. Using the previous example, if there were no naming conventions, the variable could be named "fn", which is ambiguous and would be hard to follow when reading through many lines of code. Therefore, general naming conventions, which are incorporated by many languages are needed to aid the ability to follow the code without having the author present. General naming conventions are not perfect; thus, many coding languages have adopted their own type of convention. Furthermore, there are universally used variables and special types of variables that are used without regard for a language type.

||An example of multiple cites for the same resource [[#1foot|[1]]] [[#1foot|[1]]] If it doesn't have multiple cites for the same resource just leave off the ''a'' and ''b''

||

==The Good and The Bad==

Imagine you are diving into someone's code, and you find something like this...

1 '''function''' mystery_function(''var1'', ''var2''):
2 '''for each''' vertex ''v'' in ''var1'':
3 var3[''v''] := infinity ;
4 var4[''v''] := undefined ;
5 '''end for ''';
6 var3[''var2''] := 0 ;
7 ''var5'' := the set of all nodes in ''var1'' ;
8 '''while''' ''var5'' '''is not''' empty:
9 ''var7'' := vertex in ''var5'' with smallest var3[] ;
10 '''if''' var3[''var7''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''var7'' from ''var5'' ;
14 '''for each''' neighbor ''var6'' of ''var7'':
15 ''var8'' := var3[''var7''] + dist_between(''var7'', ''var6'') ;
16 '''if''' ''var8'' < var3[''var6'']:
17 var3[''var6''] := ''var8'' ;
18 var4[''var6''] := ''var7'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' var3[] ;
23 '''end''' mystery_function.

Clearly, code without meaningful variables greatly complicates reading what the algorithm is supposed to do. Even with a slightly better example, using short 1-character variable names:

1 '''function''' mystery_function(''G'', ''s''):
2 '''for each''' vertex ''v'' in ''G'':
3 d[''v''] := infinity ;
4 p[''v''] := undefined ;
5 '''end for ''';
6 d[''s''] := 0 ;
7 ''Q'' := the set of all nodes in ''G'' ;
8 '''while''' ''Q'' '''is not''' empty:
9 ''u'' := vertex in ''Q'' with smallest d[] ;
10 '''if''' d[''u''] = infinity:
11 '''break''' ;
12 '''fi''' ;
13 remove ''u'' from ''Q'' ;
14 '''for each''' neighbor ''v'' of ''u'':
15 ''a'' := d[''u''] + dist_between(''u'', ''v'') ;
16 '''if''' ''a'' < d[''v'']:
17 d[''v''] := ''a'' ;
18 p[''v''] := ''u'' ;
19 '''fi ''' ;
20 '''end for''' ;
21 '''end while''' ;
22 '''return''' d[] ;
23 '''end''' mystery_function.

( algorithm with short-names go here )

( original algorithm goes here )

<hr >

==Notable Naming Conventions==
===General Conventions===
<hr/>

====Hungarian====

====Universally Used Variables====

====Special Variable Conventions====

<hr/>

===Language Specific Conventions===
||This is our second subtopic||

====Ruby====

====Java====

====C/C++/C#====

====.NET====

==Quick Access Table==
<table>
<tr>
<th>Type</th>
<th>Hungarian</th>
<th>Ruby</th>
<th>Java</th>
<th>C</th>
<th>.NET</th>
</tr>
<tr>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
<td>String</td>
</tr>
<tr>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
<td>Number</td>
</tr>
</table>

==Conclusions==
Variables are inevitable in programming. The naming of variables must be taken with caution so that they make sense to any who read through the code. When creating names of variables the author should take into account the language of the code, the purpose of the variable, and the type of value the variable will hold. Adhering to naming conventions is not a requirement, but they are merely guides that a programmer can use to determine the best way to name the program's variables.

==References==
1. [[#1bodya|''a'']], [[#1bodyb|''b'']] Author last, FI. (2010, April 26). Title of webpage. Retrieved October 15, 2010, from site name (Github): http://github.com/

==Additional Resources==
* Sun Java naming conventions - http://www.oracle.com/technetwork/java/codeconventions-135099.html#367
* .NET 4 naming conventions - http://msdn.microsoft.com/en-us/library/ms229045.aspx
* C++ naming conventions - http://www.cprogramming.com/tutorial/style_naming_conventions.html
* Hungarian Notation - http://en.wikipedia.org/wiki/Hungarian_notation
** Hungarian notation was invented by Microsoft programmer Charles Simonyi.
** While Hungarian notation can be applied to any programming language and environment, it was widely adopted by Microsoft for use with the C language, in particular for Microsoft Windows

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T02:28:52Z

Grepper: /* The Good and the Bad */

CSC/ECE 517 Fall 2010/ch5 5b mt

2010-11-03T02:13:29Z

Grepper:

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T05:45:13Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: #F2F2F2; border: solid thin black; padding: 5px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|frame|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|thumb|Classes are a 'type' that can combine other types.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this throw-away integer purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== Complexity =====
Oftentimes one doesn't need the functionality provided by classes to handle the problem they are trying to solve. Consequently, such an unnecessary use oftentimes over-complicates the principle design and may add unnecessary burdens to maintain the code. This regard is more so geared towards small-programs where objects and classes may not be the best fit for their implementation. Examples of this situation vary, since it is highly opinionated, but are more so an example of bad design in an object-oriented sense: to quote Albert Einstein, "Everything should be made as simple as possible, but no simpler."

 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T05:45:00Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: #F2F2F2; border: solid thin black; padding: 5px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|frame|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|thumb|Classes are a 'type' that can combine other types.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code><pre style="width:20px;">
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this throw-away integer purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== Complexity =====
Oftentimes one doesn't need the functionality provided by classes to handle the problem they are trying to solve. Consequently, such an unnecessary use oftentimes over-complicates the principle design and may add unnecessary burdens to maintain the code. This regard is more so geared towards small-programs where objects and classes may not be the best fit for their implementation. Examples of this situation vary, since it is highly opinionated, but are more so an example of bad design in an object-oriented sense: to quote Albert Einstein, "Everything should be made as simple as possible, but no simpler."

 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T05:44:44Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: #F2F2F2; border: solid thin black; padding: 5px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|frame|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|thumb|Classes are a 'type' that can combine other types.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code style="width:20px;"><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this throw-away integer purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== Complexity =====
Oftentimes one doesn't need the functionality provided by classes to handle the problem they are trying to solve. Consequently, such an unnecessary use oftentimes over-complicates the principle design and may add unnecessary burdens to maintain the code. This regard is more so geared towards small-programs where objects and classes may not be the best fit for their implementation. Examples of this situation vary, since it is highly opinionated, but are more so an example of bad design in an object-oriented sense: to quote Albert Einstein, "Everything should be made as simple as possible, but no simpler."

 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T05:44:27Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: #F2F2F2; border: solid thin black; padding: 5px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|frame|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|thumb|Classes are a 'type' that can combine other types.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code style="width:200px;"><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this throw-away integer purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== Complexity =====
Oftentimes one doesn't need the functionality provided by classes to handle the problem they are trying to solve. Consequently, such an unnecessary use oftentimes over-complicates the principle design and may add unnecessary burdens to maintain the code. This regard is more so geared towards small-programs where objects and classes may not be the best fit for their implementation. Examples of this situation vary, since it is highly opinionated, but are more so an example of bad design in an object-oriented sense: to quote Albert Einstein, "Everything should be made as simple as possible, but no simpler."

 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T05:43:57Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: #F2F2F2; border: solid thin black; padding: 5px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|frame|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|thumb|Classes are a 'type' that can combine other types.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code style="width:30em;"><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this throw-away integer purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== Complexity =====
Oftentimes one doesn't need the functionality provided by classes to handle the problem they are trying to solve. Consequently, such an unnecessary use oftentimes over-complicates the principle design and may add unnecessary burdens to maintain the code. This regard is more so geared towards small-programs where objects and classes may not be the best fit for their implementation. Examples of this situation vary, since it is highly opinionated, but are more so an example of bad design in an object-oriented sense: to quote Albert Einstein, "Everything should be made as simple as possible, but no simpler."

 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T05:40:44Z

Grepper:

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T05:37:43Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: #F2F2F2; border: solid thin black; padding: 5px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|frame|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|thumb|Classes are a 'type' that can combine other types.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this throw-away integer purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== Complexity =====
Oftentimes one doesn't need the functionality provided by classes to handle the problem they are trying to solve. Consequently, such an unnecessary use oftentimes over-complicates the principle design and may add unnecessary burdens to maintain the code. This regard is more so geared towards small-programs where objects and classes may not be the best fit for their implementation. Examples of this situation vary, since it is highly opinionated, but are more so an example of bad design in an object-oriented sense: to quote Albert Einstein, "Everything should be made as simple as possible, but no simpler."

 
===== C =====
 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T05:34:13Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: #F2F2F2; border: solid thin black; padding: 5px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|frame|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|thumb|Classes are a 'type' that can combine other types.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this throw-away integer purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== Complexity =====
Oftentimes one doesn't need the functionality provided by classes to handle the problem they are trying to solve. Consequently, such an unnecessary use oftentimes over-complicates the principle design and may add unnecessary burdens to maintain the code. Examples of this situation vary, since it is highly opinionated, but are more so an example of bad design in an object-oriented sense: to quote Albert Einstein, "Everything should be made as simple as possible, but no simpler."

 
===== C =====
 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T05:26:00Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: #F2F2F2; border: solid thin black; padding: 5px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|frame|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|thumb|Classes are a 'type' that can combine other types.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this throw-away integer purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== B =====
 
===== C =====
 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T05:05:37Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: #F2F2F2; border: solid thin black; padding: 5px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|frame|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|thumb|Classes are a 'type' that can combine other types.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>
are allowed.

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this throw-away integer purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== B =====
 
===== C =====
 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T04:21:31Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: #F2F2F2; border: solid thin black; padding: 5px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|frame|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|thumb|Classes are a 'type' that can combine other types.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>
are allowed.

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== B =====
 
===== C =====
 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T04:19:45Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: #F2F2F2; border: solid thin black; padding: 5px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|thumb|Classes are a 'type' that can combine other types.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>
are allowed.

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== B =====
 
===== C =====
 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T04:16:07Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: #F2F2F2; border: solid thin black; padding: 5px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|upright|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|thumb|Classes are a 'type' that can combine other types.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>
are allowed.

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== B =====
 
===== C =====
 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T04:14:53Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: #F2F2F2; border: solid thin black; padding: 5px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|upright|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|thumb|Types can be thought of as the set of classes ''union'' with primitive types given to a language.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>
are allowed.

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== B =====
 
===== C =====
 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T04:14:05Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: #F2F2F2; border: solid thin black; padding: 5px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|upright|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|thumb|Types can be thought of as the set of classes combined with primitive types given to a language.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>
are allowed.

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== B =====
 
===== C =====
 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T04:13:53Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: #F2F2F2; border: solid thin black; padding: 5px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|upright|thumb|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|Types can be thought of as the set of classes combined with primitive types given to a language.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>
are allowed.

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== B =====
 
===== C =====
 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T04:13:08Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: #F2F2F2; border: solid thin black; padding: 5px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|upright|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|Types can be thought of as the set of classes combined with primitive types given to a language.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>
are allowed.

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== B =====
 
===== C =====
 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T04:12:54Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: lightgrey; border: solid thin #F2F2F2; padding: 5px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|upright|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|Types can be thought of as the set of classes combined with primitive types given to a language.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>
are allowed.

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== B =====
 
===== C =====
 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T04:10:29Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: lightgrey; border: solid thin grey; padding: 5px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|upright|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|Types can be thought of as the set of classes combined with primitive types given to a language.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>
are allowed.

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== B =====
 
===== C =====
 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T04:10:17Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: lightgrey; border: solid thin grey; padding: 20px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|upright|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|Types can be thought of as the set of classes combined with primitive types given to a language.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>
are allowed.

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== B =====
 
===== C =====
 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T04:10:02Z

Grepper:

'''Types vs Classes'''
<blockquote style="background-color: lightgrey; border: solid thin grey; margin: 20px;">
Survey the differences on type vs. class in object-oriented languages. Often, the distinction is that class pertains to an object, whereas type pertains to a variable. Consider the distinction between the two terms in several different programming languages. Cover the differences between type and class, from type-theoretic definitions to practical aspects. This topic was covered three years ago (http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007), but all of the articles considered one language after the other, in a set of examples rather than a discussion of issues. Make sure that you discuss the issues, using languages as examples rather than making language the primary means of organizing the chapter.
</blockquote>

[[Image:Overall s.png|right|upright|Relationship between Type and Class]]

==Introduction==

It is often that we talk about types, strongly typed, weakly typed, classes. To make it clear, let us look into it clearly. Every programming language has a way to define a variable. A variable is a named address location which stores a particular value.

[[Image:Connection s.png|right|Types can be thought of as the set of classes combined with primitive types given to a language.]]

===Types===

Time for an analogy? Imagine a variable to be a vacant house. It could have animals, humans, robots, or another smaller house, or whatever you can think of. There has to be a way, from a third party perspective, so as to be cognizant of the kind of things that reside in the house. Types and typing is a concept which realizes this concept. A typed language or a strongly typed language is one where the type of a variable has to be declared so as to avoid any wrong dealings of the value during run time. For example, Java is a strongly typed language. If I need to use two integers for addition, I would explicitly have to mention them as an integer:-
<code><pre>
int integer1;
int integer2;
</pre></code>

However, we can’t then re-initialize it to any other type in its defined scope.
<code><pre>
integer1 = “Hello World”; // cannot map an int to a String
</pre></code>

In the case of non-typed languages, say Ruby, or Visual Basic, etc. We don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
<code><pre>
variable1 = 3
</pre></code>
as well as
<code><pre>
variable1 = “Good morning Vietnam”
</pre></code>
are allowed.

===Classes===

A class is a “type” of variable specification. The difference between a class and a regular primitive integer, character, etc is that a class:-

# consists of one or more primitive or non-primitive variables
# is a pre-defined structure
# defines methods which operate on the internal state of the object

The Type of Class is “Class”, just like the Type of integer is “integer” in case of strongly typed languages.

For example, in case of Java:-

<blockquote>“The types of the Java programming language are divided into two categories: primitive types and reference types. The primitive types are the boolean type and the numeric types. The numeric types are the integral types byte, short, int, long, and char, and the floating-point types float and double. The reference types are class types, interface types, and array types. There is also a special null type. An object is a dynamically created instance of a class type or a dynamically created array. The values of a reference type are references to objects. All objects, including arrays, support the methods of class Object . String literals are represented by String objects .” [2]</blockquote>

So, as mentioned before, in Java, there are two “Types”:-

<ol style="list-style-type:lower-roman">
<li>Primitive Type</li>
<li>Reference Type</li>
</ol>

Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.
It is sometimes confusing and difficult to come up with a clear and robust distinction between Types and Classes. One might think "Class to be a Type of Type".
It is however important to know that in strict Object Oriented Languages, Type is a union of Classes and Primitives. This rule, more or less consistent (with some deviations where primitives are treated as classes).

==Types and Classes in Languages==
===Ruby===

Ruby claims to be a strong object oriented language. It is object oriented to the extent that every thing is an object. Primitive datatypes are objects, and we can make use of the object oriented techniques on even the primitives. As mentioned before, Ruby is a dynamic typed language, as the type is bound at compile time. Everything in Ruby has a class. Every class in Ruby is inherited from class Class.

Type in Ruby is well defined as well. Using self inspection (reflection), we can find out whether a name is a Class, or a method. Let us see this in action:-

The first thing that comes to a one’s mind is something like :

<code><pre>
5.class #=> Fixnum
"hello".class #=> String

</pre></code>
But have you thought of your class as an object? Well that seems odd, but that’s how ruby works:

<code><pre>
5.class #=> Fixnum
class Foo;end #=> nil
Foo.class #=> Class
</pre></code>

What does the above snippet of code mean exactly?
It means 2 things : Foo is a constant and that constant holds(refers to) an object of Class type.

Let us prove that:
<code><pre>
Foo = Class.new
(irb):8 warning: already initialized constant Foo
=> Foo
</pre></code>
As you can see, we got a warning because we tried to initialize the constant Foo again.

So ,when you define some class ‘Foo’ in ruby, all you are doing is:
1-instantiating an object of type Class.
2-initializing a constant Foo that refers to that created object .

So, when we say “object” ,then we do mean any object; an object of Class type, or any object of any type.[3]

===Java===

As mentioned before, Java is a strongly typed language. The type of data needs to be declared before using. The types of "types" in Java are :
* Primitive Types:- boolean and numeric. The numeric types are the integral types byte, short, int, long, and char, and the
floating-point types float and double.
* Reference Types:- class types, interface types and array types. [2]

Java is an object-oriented language, but it does make a clear distinction between the primitive type and Classes. int, float, char etc. are primitives, and the other data types other than the primitives are references. It is an interesting distinction to note, because of the differences in method calling system in different languages. Java makes a distinction in "calling-by-value" when a primitive is passed as a parameter, and "calling-by-reference" when an object is passed. In fact, if a primitive is passed, a call by value is invoked, but when a Class object is passed, only a reference is passed to the object.

For a more language specific treatment of types and classes, you can refer: http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_6_ap

==Discussion of Issues==
Okay, so you're about to write a program and you need to represent data somehow. Should you use a primitive type? What about a class? There are several features that are handed to you with each.

=== Primitive Types ===
==== Advantages ====
===== Simplicity =====
In strongly typed languages, primitive types are ideal for data which doesn't necessarily need to be partitioned into several smaller components. If you are looking to store and represent a simple throw-away integer for looping, for example, there's little reason why one would want to construct a class for this purpose.

Primitive types are also often times coupled with native operations, handed to you by the language. For example, in Java, variables of type int are automatically given operations such as addition, subtraction, multiplication, and so on. These operations work as follows:
# Receive both inputs
# Cast if necessary (for example, from an int to a double)
# Perform calculation
# Return result

It is important to note that the primitive types themselves are left ''unchanged'', and the result is returned from the operation, giving the programmer the ability to place the result elsewhere.

===== Efficiency =====
In efficiency-critical applications, primitive types and their operations are oftentimes mapped directly to hardware-supported equivalents, thus operations can be performed very quickly. This style of downgrading the logic to more so the hardware level has been replaced over the years for general applications, since improvements to hardware components have eradicated the once-imperative necessity to program efficiently. Another point of view concerning efficiency could be from development time: if the program one is writing doesn't require complex design, it would be quicker to use the language's built-in types instead of taking the time to design a class to do the same feature.

==== Disadvantages ====
===== Single-state storage =====
One large disadvantages to primitive types are that they are generally capable of only holding a single dimension state. This limitation requires the programmer to use other variables in conjunction if they desire to hold more than one field of data.

===== Refactoring =====
Since primitive types do not allow you to encapsulate your data, if you ever desire to change the behavior of your program, you are forced to manually check each use of the variable for enforcement.

For example, suppose you have a system designed in Java that maintains an integer value which represents the number of books you have in a library.
<code><pre>
int numBooks;
...
numBooks = 0;
...
numBooks++;
...
numBooks--;
...
</pre></code>

A few days later, you realize that you should probably refactor your system to maintain a log of when this variable updates. You immediately face a problem since, as it is, your code directly manipulates a single-state type integer. Without resorting to a more object-oriented solution, you would have to update each location in the code of where a change takes place in order to establish this bookkeeping (pun intended).
<code id="bookKeeping"><pre>
public static void integerValueChanged(){
// records that the value has been changed
...
}

public static void main(String[]args){
int numBooks;
...
numBooks = 0;
integerValueChanged();
...
numBooks++;
integerValueChanged();
...
numBooks--;
integerValueChanged();
...
}
</pre></code>

To generalize this concept, it is oftentimes necessary to modify "what happens" when something is updated, and this cannot be easily accomplished by merely using primitive types.

=== Class Types ===
Classes to the rescue! Classes give programmers the ability to construct complex data types that are also capable of defining their own operations, all while keeping the details and specifics black-boxed outsize of where the class will be used in the code.
==== Advantages ====
===== Multi-dimensional Storage =====
Contrasting to primitive types, classes allow programmers to couple a varying number of fields. Grouping fields of data into a single class, then instantiating such an object and manipulating it is much more convenient than keeping track of several individual variables.

===== Refactoring =====
Oftentimes it is necessary to refactor a system to execute code when a change happens. In object-land, we are able to do this through the ability to control what happens in our methods.

Taking our [[#bookKeeping| example from above]], we can give a quick example of how a class could be defined to handle the situation much more elegantly.
<code><pre>
public class RecordedNumber{
// The integer value, kept concealed in the class
private int value;

public RecordedNumber(int value){
this.value = value;
}

public int getValue(){
return value;
}

public void setValue(int newValue){
// code to do any necessary recording.
...
this.value = newValue;
}
}

public class MyExample{
public static void main(String[]args){
RecordedNumber numBooks = new RecordedNumber(0);
...
numBooks.setValue(4); // the object handles all necessary bookkeeping
...
}
}
</pre></code>
 

===== Code-reuse =====
Another nice feature to class-types encapsulate the concept surrounding code re-usability, especially in topics such as inheritance. Classes allow the programmer to enhance an already existing class-type to be more specific, which in turn can prevent excessive code duplication.

===== Application Structure =====
Designing an application in a object-oriented / class-specific style can reduce the challenges of designing and building a difficult system into merely making objects successfully interact. It is from this concept that languages such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language (UML)] have been created, allowing software engineers to build around the notion of classes and their relationships to one another.

 
==== Disadvantages ====
===== Speed Considerations =====
In computational-intensive applications, objects built from classes tend to be less efficient than primitive data types built around procedural context. This is due in part because of the object's creation, since it isn't supported directly hardware level. Consideration is placed more so on good-design and coding-practices when implementing functionality around classes.
 
===== B =====
 
===== C =====
 

==References==
[1] http://download.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

[2] Java:- Types, Values and Variables
http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html
[3] Ruby Reflection ,http://www.khelll.com/blog/ruby/ruby-reflection/