Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T03:45:45Z

Pseudonym1:

'''Types vs Classes'''

[[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” are allowed.
</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 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-21T03:23:52Z

Pseudonym1:

'''Types vs Classes'''

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

===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” are allowed.
</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. This can be shown

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-21T03:14:29Z

Pseudonym1:

'''Types vs Classes'''

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

===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” are allowed.
</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.

==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. This can be shown

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-21T03:09:35Z

Pseudonym1:

'''Types vs Classes'''

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

===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” are allowed.
</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.

==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. This can be shown

==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-21T01:21:02Z

Pseudonym1:

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-21T00:18:09Z

Pseudonym1:

'''Types vs Classes'''

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

===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 2 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 do a character initialization in the course of a program.
<code><pre>
integer1 = “Hello World”;
</pre></code>

Is however, not allowed.

whereas, in case of non-typed languages, say Ruby, or Visual Basic etc. for example, we don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
variable1 = 3
as well as
variable1 = “Good morning Vietnam” 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 is:-

1)A class consists of one or more primitive or non-primitive variables
2)It is a pre defined structure

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

For example, in case of Java:-

“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]

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

i)Primitive Type
ii)Reference Type :- Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.

==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. This can be shown

==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-20T23:42:34Z

Pseudonym1:

'''Types vs Classes'''

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

===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 2 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 do a character initialization in the course of a program.
<code><pre>
integer1 = “Hello World”;
</pre></code>

Is however, not allowed.

whereas, in case of non-typed languages, say Ruby, or Visual Basic etc. for example, we don’t need to specify a type.
<code><pre>
def variable1;
def variable2;
</pre></code>

Now, it could be initialized with anything,
variable1 = 3
as well as
variable1 = “Good morning Vietnam” 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 is:-

1)A class consists of one or more primitive or non-primitive variables
2)It is a pre defined structure

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

For example, in case of Java:-

“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]

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

i)Primitive Type
ii)Reference Type :- Classes, Interfaces, Arrays are all consolidations of Primitive types, so they just need to “point” to or reference the primitive ones, hence the name.

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

==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-20T22:58:53Z

Pseudonym1:

CSC/ECE 517 Fall 2010/ch3 4b mt

2010-10-20T22:12:11Z

Pseudonym1:

CSC/ECE 517 Fall 2010/ch1 S10 ms

2010-10-20T21:53:29Z

Pseudonym1: Types vs Class

*[[CSC/ECE 517 Fall 2010/ch1 1a vc]]

*[[CSC/ECE 517 Fall 2010/ch1 1a br]]

*[[CSC/ECE 517 Fall 2010/ch1 1b mg]]

*[[CSC/ECE 517 Fall 2010/ch1 1c JF]]

*[[CSC/ECE 517 Fall 2010/ch1 1e az]]

*[[CSC/ECE 517 Fall 2010/ch1 1e bb]]

*[[CSC/ECE 517 Fall 2010/ch1 1f vn]]

*[[CSC/ECE 517 Fall 2010/ch1 25 ag]]

*[[CSC/ECE 517 Fall 2010/ch2 2b dg]]

*[[CSC/ECE 517 Fall 2010/ch1 2e RI]]

*[[CSC/ECE 517 Fall 2010/ch1 S6 aa]]

*[[CSC/ECE 517 Fall 2010/ch1 S6 km]]

*[[CSC/ECE 517 Fall 2010/ch1 S10 GP]]

*[[CSC/ECE 517 Fall 2010/ch1 S10 MS]]

*[[CSC/ECE 517 Fall 2010/ch1 S10 MM]]

*[[CSC/ECE 517 Fall 2010/ch1 S10 PH]]

*[[CSC/ECE 517 Fall 2010/ch2 2a CB]]

*[[CSC/ECE 517 Fall 2010/ch2 2a mw]]

*[[CSC/ECE 517 Fall 2010/ch2 2c ck]]

*[[CSC/ECE 517 Fall 2010/ch2 S23 GP]]

*[[CSC/ECE 517 Fall 2010/ch2 S24 NS]]

*[[CSC/ECE 517 Fall 2010/ch2 S23 SS]]

*[[CSC/ECE 517 Fall 2010/ch2 S23 NR]]

*[[CSC/ECE 517 Fall 2010/ch2 S20 TT]]

*[[CSC/ECE 517 Fall 2010/ch2 2d AS]]

*[[CSC/ECE 517 Fall 2010/ch3 3j KS]]

*[[CSC/ECE 517 Fall 2010/ch2 S24 rm]]

*[[CSC/ECE 517 Fall 2010/ch3 3h PW]]

*[[CSC/ECE 517 Fall 2010/ch3 3e br]]

*[[CSC/ECE 517 Fall 2010/ch3 3h az]]

*[[CSC/ECE 517 Fall 2010/ch3 3i IC]]

*[[CSC/ECE 517 Fall 2010/ch3 3i MM]]

*[[CSC/ECE 517 Fall 2010/ch3 3a SN]]

*[[CSC/ECE 517 Fall 2010/ch3 S30 SK]]

*[[CSC/ECE 517 Fall 2010/ch3 3f lj]]

*[[CSC/ECE 517 Fall 2010/ch3 3b ka]]

*[[CSC/ECE 517 Fall 2010/ch3 4b mt]]

*[[CSC/ECE 517 Fall 2010/ch4 4c rn]]

*[[CSC/ECE 517 Fall 2010/ch4 4h am]]

*[[CSC/ECE 517 Fall 2010/ch4 4g HW]]

*[[CSC/ECE 517 Fall 2010/ch4 4g km]]

*[[CSC/ECE 517 Fall 2010/ch4 4f sv]]

*[[CSC/ECE 517 Fall 2010/ch4 4e ms]]

CSC/ECE 517 Fall 2010/ch1 1a vc

2010-09-06T04:44:17Z

Pseudonym1:

==Introduction==
Versioning Systems are typically used in a software facility(s), and employed for the primary purposes of collaborative work. While working on a project with common resources (files, folders, information etc.), it becomes essential to put a definite order on the sanctity of the data if the resources are editable.

For example, if there are 10 people working on an assignment, and 3 people are working on the same file. It becomes important on how they can add/modify data such that all are neither locked out waiting for a lock put by anyone, nor there is any inconsistency in the data.

Version control systems typically let us create versions of the resources, where each developer can work on a different version, therefore providing the flexibility. There are a whole bunch of features provided by the new Versioning Systems. We shall look at the evolution and history of the same in the subsequent sections.

==Taxonomy of Version Control==

Branch : When the development team needs to work on two distinct copies of a project, a branch is created. [4] The branch is a replica of the existing code at the time of its creation. On creation of the branch, changes made to a branch are confined to it and are not visible in any other branch.

Repository: Repository is the data store where all the versions of all the files in the project are stored. A repository may be centralized or distributed.

Check-Out: Creating a working copy of the files in the repository on a local machine is called Check-out. Every user who checks out a file has a working copy of the file on his computer. Changes made to the working copy are not visible to the team members

Check-In: Putting back the edited files to the repository for use by everybody is called Check-In

Merge=: Merging is the process of combining different working copies of the file into the repository.[3] Each developer is allowed to work on their independent working copies, and everyone’s changes to a single file are combined by merging

Label: A label is an identifier given to a branch when created. Also known as Tag

Trunk: The highest location of the repository is called Trunk.

==History==

===Source Code Control System (SCCS)===

The exact time in history when and how the version systems came about into existence is unclear. However, we can estimate roughly that the version control system can be rooted to the Source Code Control System (SCCS) [3],[6]. It was developed by the Bell Labs in 1972. It is no longer prevalent, but the file format is still internally used today by other softwares like BitKeeper and Sablime[6]

===Revision Control System(RCS)===

The next generation of Version control system was the RCS. It was first released in 1982, and developed by Walter F. Tichy of Purdue University. It was considered to be a better version of SCCS. Also, the version syntax was very complicated. Usually the developers employed locking mechanism, and worked on a single branch(head).

One situation where RCS could prove to be useful is while a single user needs to work on a project. As RCS does not demand a central repository to be set up, and the administration and maintenance of files is easy, hence, it is easy.

The limitations of RCS were that RCS could only work on a single file. There was no way that multiple files in a project could be versioned.[7]

===Concurrent Versions System(CVS)===

CVS was one step ahead in the evolution of the Version control Systems. CVS is distributed under the public GNU license. One major advantage where the CVS edges over RCS is its Client-Server Architecture. RCS did not support a client-server architecture, which made it difficult for distributed development.

CVS based systems provided for the first, the ability to check out a version of the main copy in the repository. The developers could work on their individual copies, and later, push it back into their branches. Once all the development on the files was done, the developers could merge their code with the live copy. There is however a restriction posed by the CVS systems, that is it only allows modification of code on the latest version. This calls for the developers to regularly sync their code with main copy in the repository, so that the modifications done by other people are also covered.

CVS uses delta compression technique to save space on the multiple copies of the same files. In short, the CVS systems keep only one copy per se. Wherever another set of copy is needed, it just stores the differences from the original copy. If there is no difference between the two, then the 2 files are in sync, else out of sync. For more details, the Delta Compression could be accessed at http://en.wikipedia.org/wiki/Delta_compression

One of the biggest advantages of the CVS system was the ability for distributed development. However, there were quite a few areas where it lacked and called for better methods. To name a few, CVS could only work reliably with ASCII characters. It did not work well with other character sets for example UTF.Also, there was no atomicity of operations i.e. there was no way to ensure commit or rollback in case of an error. A detailed list of criticisms is mentioned at http://en.wikipedia.org/wiki/Concurrent_Versions_System#Criticism .

===Subversioning(SVN)===

Working on most of the criticisms of CVS mentioned before, in 2000, attempt to improve the structure of the CVS. The developers did not want to change the philosophy or change the structure of CVS in a totally new way, they just wanted to revamp whatever was done before. Partly because CVS was then the de facto standard for version control. [9]

== References ==
*[1]: [http://en.wikipedia.org/wiki/Revision_control Revision Control Wikipedia]
*[2]: [http://en.wikipedia.org/wiki/Concurrent_Versions_System Concurrent Version Systems(CVS)]
*[3]: [http://www.ibm.com/developerworks/java/library/j-subversion/index.html#N1007B]
*[4]: [http://www.ericsink.com/scm/scm_branches.html]
*[5]: [http://www.tigris.org/nonav/scdocs/ddCVS_cvsglossary.html]
*[6]: [http://en.wikipedia.org/wiki/Source_Code_Control_System]
*[7]: [http://en.wikipedia.org/wiki/Revision_Control_System]
*[8]: [http://en.wikipedia.org/wiki/Concurrent_Versions_System]
*[9]: [http://svnbook.red-bean.com/en/1.1/ch01s02.html]

CSC/ECE 517 Fall 2010/ch1 1a vc

2010-09-06T04:40:02Z

Pseudonym1:

==Introduction==
Versioning Systems are typically used in a software facility(s), and employed for the primary purposes of collaborative work. While working on a project with common resources (files, folders, information etc.), it becomes essential to put a definite order on the sanctity of the data if the resources are editable.

For example, if there are 10 people working on an assignment, and 3 people are working on the same file. It becomes important on how they can add/modify data such that all are neither locked out waiting for a lock put by anyone, nor there is any inconsistency in the data.

Version control systems typically let us create versions of the resources, where each developer can work on a different version, therefore providing the flexibility. There are a whole bunch of features provided by the new Versioning Systems. We shall look at the evolution and history of the same in the subsequent sections.

==Taxonomy of Version Control==

Branch : When the development team needs to work on two distinct copies of a project, a branch is created. [4] The branch is a replica of the existing code at the time of its creation. On creation of the branch, changes made to a branch are confined to it and are not visible in any other branch.

Repository: Repository is the data store where all the versions of all the files in the project are stored. A repository may be centralized or distributed.

Check-Out: Creating a working copy of the files in the repository on a local machine is called Check-out. Every user who checks out a file has a working copy of the file on his computer. Changes made to the working copy are not visible to the team members

Check-In: Putting back the edited files to the repository for use by everybody is called Check-In

Merge=: Merging is the process of combining different working copies of the file into the repository.[3] Each developer is allowed to work on their independent working copies, and everyone’s changes to a single file are combined by merging

Label: A label is an identifier given to a branch when created. Also known as Tag

Trunk: The highest location of the repository is called Trunk.

==History==

===Source Code Control System (SCCS)===

The exact time in history when and how the version systems came about into existence is unclear. However, we can estimate roughly that the version control system can be rooted to the Source Code Control System (SCCS) [3],[6]. It was developed by the Bell Labs in 1972. It is no longer prevalent, but the file format is still internally used today by other softwares like BitKeeper and Sablime[6]

===Revision Control System(RCS)===

The next generation of Version control system was the RCS. It was first released in 1982, and developed by Walter F. Tichy of Purdue University. It was considered to be a better version of SCCS. Also, the version syntax was very complicated. Usually the developers employed locking mechanism, and worked on a single branch(head).

One situation where RCS could prove to be useful is while a single user needs to work on a project. As RCS does not demand a central repository to be set up, and the administration and maintenance of files is easy, hence, it is easy.

The limitations of RCS were that RCS could only work on a single file. There was no way that multiple files in a project could be versioned.[7]

===Concurrent Versions System(CVS)===

CVS was one step ahead in the evolution of the Version control Systems. CVS is distributed under the public GNU license. One major advantage where the CVS edges over RCS is its Client-Server Architecture. RCS did not support a client-server architecture, which made it difficult for distributed development.

CVS based systems provided for the first, the ability to check out a version of the main copy in the repository. The developers could work on their individual copies, and later, push it back into their branches. Once all the development on the files was done, the developers could merge their code with the live copy. There is however a restriction posed by the CVS systems, that is it only allows modification of code on the latest version. This calls for the developers to regularly sync their code with main copy in the repository, so that the modifications done by other people are also covered.

CVS uses delta compression technique to save space on the multiple copies of the same files. In short, the CVS systems keep only one copy per se. Wherever another set of copy is needed, it just stores the differences from the original copy. If there is no difference between the two, then the 2 files are in sync, else out of sync. For more details, the Delta Compression could be accessed at http://en.wikipedia.org/wiki/Delta_compression

One of the biggest advantages of the CVS system was the ability for distributed development. However, there were quite a few areas where it lacked and called for better methods. To name a few, CVS could only work reliably with ASCII characters. It did not work well with other character sets for example UTF.Also, there was no atomicity of operations i.e. there was no way to ensure commit or rollback in case of an error. A detailed list of criticisms is mentioned at http://en.wikipedia.org/wiki/Concurrent_Versions_System#Criticism 

===Subversioning(SVN)===

Working on most of the criticisms of CVS mentioned before, in 2000, attempt to improve the structure of the CVS. The developers did not want to change the philosophy or change the structure of CVS in a totally new way, they just wanted to revamp whatever was done before. Partly because CVS was then the de facto standard for version control. [9]

== References ==
*[1]: [http://en.wikipedia.org/wiki/Revision_control Revision Control Wikipedia]
*[2]: [http://en.wikipedia.org/wiki/Concurrent_Versions_System Concurrent Version Systems(CVS)]
*[3]: [http://www.ibm.com/developerworks/java/library/j-subversion/index.html#N1007B]
*[4]: [http://www.ericsink.com/scm/scm_branches.html]
*[5]: [http://www.tigris.org/nonav/scdocs/ddCVS_cvsglossary.html]
*[6]: [http://en.wikipedia.org/wiki/Source_Code_Control_System]
*[7]: [http://en.wikipedia.org/wiki/Revision_Control_System]
*[8]: [http://en.wikipedia.org/wiki/Concurrent_Versions_System]
*[9]: [http://svnbook.red-bean.com/en/1.1/ch01s02.html]

CSC/ECE 517 Fall 2010/ch1 1a vc

2010-09-06T04:37:39Z

Pseudonym1:

==Introduction==
Versioning Systems are typically used in a software facility(s), and employed for the primary purposes of collaborative work. While working on a project with common resources (files, folders, information etc.), it becomes essential to put a definite order on the sanctity of the data if the resources are editable.

For example, if there are 10 people working on an assignment, and 3 people are working on the same file. It becomes important on how they can add/modify data such that all are neither locked out waiting for a lock put by anyone, nor there is any inconsistency in the data.

Version control systems typically let us create versions of the resources, where each developer can work on a different version, therefore providing the flexibility. There are a whole bunch of features provided by the new Versioning Systems. We shall look at the evolution and history of the same in the subsequent sections.

==Taxonomy of Version Control==

===Branch===: When the development team needs to work on two distinct copies of a project, a branch is created. [4] The branch is a replica of the existing code at the time of its creation. On creation of the branch, changes made to a branch are confined to it and are not visible in any other branch.

===Repository===: Repository is the data store where all the versions of all the files in the project are stored. A repository may be centralized or distributed.

===Check-Out===: Creating a working copy of the files in the repository on a local machine is called Check-out. Every user who checks out a file has a working copy of the file on his computer. Changes made to the working copy are not visible to the team members

===Check-In===: Putting back the edited files to the repository for use by everybody is called Check-In

===Merge===: Merging is the process of combining different working copies of the file into the repository.[3] Each developer is allowed to work on their independent working copies, and everyone’s changes to a single file are combined by merging

===Label===: A label is an identifier given to a branch when created. Also known as Tag

===Trunk===: The highest location of the repository is called Trunk.

==History==

===Source Code Control System (SCCS)===

The exact time in history when and how the version systems came about into existence is unclear. However, we can estimate roughly that the version control system can be rooted to the Source Code Control System (SCCS) [3],[6]. It was developed by the Bell Labs in 1972. It is no longer prevalent, but the file format is still internally used today by other softwares like BitKeeper and Sablime[6]

===Revision Control System(RCS)===

The next generation of Version control system was the RCS. It was first released in 1982, and developed by Walter F. Tichy of Purdue University. It was considered to be a better version of SCCS. Also, the version syntax was very complicated. Usually the developers employed locking mechanism, and worked on a single branch(head).

One situation where RCS could prove to be useful is while a single user needs to work on a project. As RCS does not demand a central repository to be set up, and the administration and maintenance of files is easy, hence, it is easy.

The limitations of RCS were that RCS could only work on a single file. There was no way that multiple files in a project could be versioned.[7]

===Concurrent Versions System(CVS)===

CVS was one step ahead in the evolution of the Version control Systems. CVS is distributed under the public GNU license. One major advantage where the CVS edges over RCS is its Client-Server Architecture. RCS did not support a client-server architecture, which made it difficult for distributed development.

CVS based systems provided for the first, the ability to check out a version of the main copy in the repository. The developers could work on their individual copies, and later, push it back into their branches. Once all the development on the files was done, the developers could merge their code with the live copy. There is however a restriction posed by the CVS systems, that is it only allows modification of code on the latest version. This calls for the developers to regularly sync their code with main copy in the repository, so that the modifications done by other people are also covered.

CVS uses delta compression technique to save space on the multiple copies of the same files. In short, the CVS systems keep only one copy per se. Wherever another set of copy is needed, it just stores the differences from the original copy. If there is no difference between the two, then the 2 files are in sync, else out of sync. For more details, the Delta Compression could be accessed at http://en.wikipedia.org/wiki/Delta_compression

One of the biggest advantages of the CVS system was the ability for distributed development. However, there were quite a few areas where it lacked and called for better methods. To name a few, CVS could only work reliably with ASCII characters. It did not work well with other character sets for example UTF.Also, there was no atomicity of operations i.e. there was no way to ensure commit or rollback in case of an error. A detailed list of criticisms is mentioned at http://en.wikipedia.org/wiki/Concurrent_Versions_System#Criticism 

===Subversioning(SVN)===

Working on most of the criticisms of CVS mentioned before, in 2000, attempt to improve the structure of the CVS. The developers did not want to change the philosophy or change the structure of CVS in a totally new way, they just wanted to revamp whatever was done before. Partly because CVS was then the de facto standard for version control. [9]

== References ==
*[1]: [http://en.wikipedia.org/wiki/Revision_control Revision Control Wikipedia]
*[2]: [http://en.wikipedia.org/wiki/Concurrent_Versions_System Concurrent Version Systems(CVS)]
*[3]: [http://www.ibm.com/developerworks/java/library/j-subversion/index.html#N1007B]
*[4]: [http://www.ericsink.com/scm/scm_branches.html]
*[5]: [http://www.tigris.org/nonav/scdocs/ddCVS_cvsglossary.html]
*[6]: [http://en.wikipedia.org/wiki/Source_Code_Control_System]
*[7]: [http://en.wikipedia.org/wiki/Revision_Control_System]
*[8]: [http://en.wikipedia.org/wiki/Concurrent_Versions_System]
*[9]: [http://svnbook.red-bean.com/en/1.1/ch01s02.html]

CSC/ECE 517 Fall 2010/ch1 1a vc

2010-09-06T04:35:26Z

Pseudonym1:

==Introduction==
Versioning Systems are typically used in a software facility(s), and employed for the primary purposes of collaborative work. While working on a project with common resources (files, folders, information etc.), it becomes essential to put a definite order on the sanctity of the data if the resources are editable.

For example, if there are 10 people working on an assignment, and 3 people are working on the same file. It becomes important on how they can add/modify data such that all are neither locked out waiting for a lock put by anyone, nor there is any inconsistency in the data.

Version control systems typically let us create versions of the resources, where each developer can work on a different version, therefore providing the flexibility. There are a whole bunch of features provided by the new Versioning Systems. We shall look at the evolution and history of the same in the subsequent sections.

==Taxonomy of Version Control==

Branch: When the development team needs to work on two distinct copies of a project, a branch is created. [4] The branch is a replica of the existing code at the time of its creation. On creation of the branch, changes made to a branch are confined to it and are not visible in any other branch.

Repository: Repository is the data store where all the versions of all the files in the project are stored. A repository may be centralized or distributed.

Check-Out: Creating a working copy of the files in the repository on a local machine is called Check-out. Every user who checks out a file has a working copy of the file on his computer. Changes made to the working copy are not visible to the team members

Check-In: Putting back the edited files to the repository for use by everybody is called Check-In

Merge: Merging is the process of combining different working copies of the file into the repository.[3] Each developer is allowed to work on their independent working copies, and everyone’s changes to a single file are combined by merging

Label: A label is an identifier given to a branch when created. Also known as Tag

Trunk: The highest location of the repository is called Trunk.

==History==

Source Code Control System (SCCS)

The exact time in history when and how the version systems came about into existence is unclear. However, we can estimate roughly that the version control system can be rooted to the Source Code Control System (SCCS) [3],[6]. It was developed by the Bell Labs in 1972. It is no longer prevalent, but the file format is still internally used today by other softwares like BitKeeper and Sablime[6]

Revision Control System(RCS)

The next generation of Version control system was the RCS. It was first released in 1982, and developed by Walter F. Tichy of Purdue University. It was considered to be a better version of SCCS. Also, the version syntax was very complicated. Usually the developers employed locking mechanism, and worked on a single branch(head).

One situation where RCS could prove to be useful is while a single user needs to work on a project. As RCS does not demand a central repository to be set up, and the administration and maintenance of files is easy, hence, it is easy.

The limitations of RCS were that RCS could only work on a single file. There was no way that multiple files in a project could be versioned.[7]

Concurrent Versions System(CVS)

CVS was one step ahead in the evolution of the Version control Systems. CVS is distributed under the public GNU license. One major advantage where the CVS edges over RCS is its Client-Server Architecture. RCS did not support a client-server architecture, which made it difficult for distributed development.

CVS based systems provided for the first, the ability to check out a version of the main copy in the repository. The developers could work on their individual copies, and later, push it back into their branches. Once all the development on the files was done, the developers could merge their code with the live copy. There is however a restriction posed by the CVS systems, that is it only allows modification of code on the latest version. This calls for the developers to regularly sync their code with main copy in the repository, so that the modifications done by other people are also covered.

CVS uses delta compression technique to save space on the multiple copies of the same files. In short, the CVS systems keep only one copy per se. Wherever another set of copy is needed, it just stores the differences from the original copy. If there is no difference between the two, then the 2 files are in sync, else out of sync. For more details, the Delta Compression could be accessed at http://en.wikipedia.org/wiki/Delta_compression

One of the biggest advantages of the CVS system was the ability for distributed development. However, there were quite a few areas where it lacked and called for better methods. To name a few, CVS could only work reliably with ASCII characters. It did not work well with other character sets for example UTF.Also, there was no atomicity of operations i.e. there was no way to ensure commit or rollback in case of an error. A detailed list of criticisms is mentioned at http://en.wikipedia.org/wiki/Concurrent_Versions_System#Criticism 

Subversioning(SVN)

Working on most of the criticisms of CVS mentioned before, in 2000, attempt to improve the structure of the CVS. The developers did not want to change the philosophy or change the structure of CVS in a totally new way, they just wanted to revamp whatever was done before. Partly because CVS was then the de facto standard for version control. [9]

== References ==
*[1]: [http://en.wikipedia.org/wiki/Revision_control Revision Control Wikipedia]
*[2]: [http://en.wikipedia.org/wiki/Concurrent_Versions_System Concurrent Version Systems(CVS)]
*[3]: [http://www.ibm.com/developerworks/java/library/j-subversion/index.html#N1007B]
*[4]: [http://www.ericsink.com/scm/scm_branches.html]
*[5]: [http://www.tigris.org/nonav/scdocs/ddCVS_cvsglossary.html]
*[6]: [http://en.wikipedia.org/wiki/Source_Code_Control_System]
*[7]: [http://en.wikipedia.org/wiki/Revision_Control_System]
*[8]: [http://en.wikipedia.org/wiki/Concurrent_Versions_System]
*[9]: [http://svnbook.red-bean.com/en/1.1/ch01s02.html]

CSC/ECE 517 Fall 2010/ch1 1a vc

2010-09-06T02:55:48Z

Pseudonym1:

==Introduction==
Versioning Systems are typically used in a software facility(s), and employed for the primary purposes of collaborative work. While working on a project with common resources (files, folders, information etc.), it becomes essential to put a definite order on the sanctity of the data if the resources are editable.

For example, if there are 10 people working on an assignment, and 3 people are working on the same file. It becomes important on how they can add/modify data such that all are neither locked out waiting for a lock put by anyone, nor there is any inconsistency in the data.

Version control systems typically let us create versions of the resources, where each developer can work on a different version, therefore providing the flexibility. There are a whole bunch of features provided by the new Versioning Systems. We shall look at the evolution and history of the same in the subsequent sections.

==Taxonomy of Version Control==

Branch: When the development team needs to work on two distinct copies of a project, a branch is created. [4] The branch is a replica of the existing code at the time of its creation. On creation of the branch, changes made to a branch are confined to it and are not visible in any other branch.

Repository: Repository is the data store where all the versions of all the files in the project are stored. A repository may be centralized or distributed.

Check-Out: Creating a working copy of the files in the repository on a local machine is called Check-out. Every user who checks out a file has a working copy of the file on his computer. Changes made to the working copy are not visible to the team members

Check-In: Putting back the edited files to the repository for use by everybody is called Check-In

Merge: Merging is the process of combining different working copies of the file into the repository.[3] Each developer is allowed to work on their independent working copies, and everyone’s changes to a single file are combined by merging

Label: A label is an identifier given to a branch when created. Also known as Tag

Trunk: The highest location of the repository is called Trunk.

==History==

Source Code Control System (SCCS)

The exact time in history when and how the version systems came about into existence is unclear. However, we can estimate roughly that the version control system can be rooted to the Source Code Control System (SCCS) [3],[6]. It was developed by the Bell Labs in 1972. It is no longer prevalent, but the file format is still internally used today by other softwares like BitKeeper and Sablime[6]

Revision Control System(RCS)

The next generation of Version control system was the RCS. It was first released in 1982, and developed by Walter F. Tichy of Purdue University. It was considered to be a better version of SCCS. Also, the version syntax was very complicated. Usually the developers employed locking mechanism, and worked on a single branch(head).

One situation where RCS could prove to be useful is while a single user needs to work on a project. As RCS does not demand a central repository to be set up, and the administration and maintenance of files is easy, hence, it is easy.

The limitations of RCS were that RCS could only work on a single file. There was no way that multiple files in a project could be versioned.[7]

Concurrent Versions System(CVS)

CVS was one step ahead in the evolution of the Version control Systems. CVS is distributed under the public GNU license. One major advantage where the CVS edges over RCS is its Client-Server Architecture. RCS did not support a client-server architecture, which made it difficult for distributed development.

CVS based systems provided for the first, the ability to check out a version of the main copy in the repository. The developers could work on their individual copies, and later, push it back into their branches. Once all the development on the files was done, the developers could merge their code with the live copy. There is however a restriction posed by the CVS systems, that is it only allows modification of code on the latest version. This calls for the developers to regularly sync their code with main copy in the repository, so that the modifications done by other people are also covered.

CVS uses delta compression technique to save space on the multiple copies of the same files. In short, the CVS systems keep only one copy per se. Wherever another set of copy is needed, it just stores the differences from the original copy. If there is no difference between the two, then the 2 files are in sync, else out of sync. For more details, the Delta Compression could be accessed at http://en.wikipedia.org/wiki/Delta_compression
== References ==
*[1]: [http://en.wikipedia.org/wiki/Revision_control Revision Control Wikipedia]
*[2]: [http://en.wikipedia.org/wiki/Concurrent_Versions_System Concurrent Version Systems(CVS)]
*[3]: [http://www.ibm.com/developerworks/java/library/j-subversion/index.html#N1007B]
*[4]: [http://www.ericsink.com/scm/scm_branches.html]
*[5]: [http://www.tigris.org/nonav/scdocs/ddCVS_cvsglossary.html]
*[6]: [http://en.wikipedia.org/wiki/Source_Code_Control_System]
*[7] :[http://en.wikipedia.org/wiki/Revision_Control_System]

CSC/ECE 517 Fall 2010/ch1 1a vc

2010-09-06T02:32:24Z

Pseudonym1:

CSC/ECE 517 Fall 2010/ch1 1a vc

2010-09-05T23:38:47Z

Pseudonym1:

CSC/ECE 517 Fall 2010/ch1 1a vc

2010-09-05T23:16:29Z

Pseudonym1:

CSC/ECE 517 Fall 2010/ch1 1a vc

2010-09-05T22:57:28Z

Pseudonym1:

CSC/ECE 517 Fall 2010/ch1 1a vc

2010-09-05T22:56:50Z

Pseudonym1:

CSC/ECE 517 Fall 2010/ch1 1a vc

2010-09-05T22:54:14Z

Pseudonym1:

CSC/ECE 517 Fall 2010/ch1 1a vc

2010-09-05T22:49:12Z

Pseudonym1:

CSC/ECE 517 Fall 2010/ch1 S10 MS

2010-09-05T22:48:24Z

Pseudonym1:

This is the main page for the wiki contributions for CSC/ECE 517, Object-Oriented Languages and Systems, Fall 2010.

* [[CSC/ECE 517 Fall 2010/ch1 1a vc]]

History of Versioning Systems

2010-09-05T22:03:44Z

Pseudonym1: /* References */

History of Versioning Systems

2010-09-05T21:48:57Z

Pseudonym1: /* References */

== References ==
* [http://en.wikipedia.org/wiki/Revision_control Revision Control Wikipedia]
*[http://en.wikipedia.org/wiki/Concurrent_Versions_System Concurrent Version Systems(CVS)]

History of Versioning Systems

2010-09-05T21:38:31Z

Pseudonym1:

== References ==
* [http://en.wikipedia.org/wiki/Revision_control Revision Control Wikipedia]

CSC/ECE 517 Fall 2010/ch1 S10 MS

2010-09-05T21:37:04Z

Pseudonym1:

This is the main page for the wiki contributions for CSC/ECE 517, Object-Oriented Languages and Systems, Fall 2010.

* [[History of Versioning Systems]]

CSC/ECE 517 Fall 2010/ch1 S10 MS

2010-09-05T21:31:13Z

Pseudonym1:

This is the main page for the wiki contributions for CSC/ECE 517, Object-Oriented Languages and Systems, Fall 2010.

Template:History of Version Control

2010-09-05T21:27:52Z

Pseudonym1:

Template:History of Version Control

2010-09-05T21:26:43Z

Pseudonym1: /* References */

This page contains the Wiki Chapter on the History of Versioning Systems. This is an attempt to demonstrate the historical development of the version systems; how they performed, and evolved. Much of the help in writing this article is taken from the Wikipedia page, which is provided in the references section along with other references for detailed perusal.

Template:History of Version Control

2010-09-05T21:22:01Z

Pseudonym1:

CSC/ECE 517 Fall 2010/ch1 S10 MS

2010-09-05T21:01:35Z

Pseudonym1:

This is the main page for the wiki contributions for CSC/ECE 517, Object-Oriented Languages and Systems, Fall 2010.

Wiki Links :List of Readings

* {{History of Version Control|anchor}}