Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T20:41:22Z

Sgurram: /* Conclusion */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

Some class names for the present scenario are 

Customer 
Flight 
Airport 
Segment 
Ticket 
Cost 

Some nouns that are not classes are 

Seats 
Alternate Flights 
Outbound Flight 
Inbound Flight 

Some of the responsibilities of the Customer class and their collaborators are 
* to make payment(R) shopping cart(C)
* to choose the flight(R) Flight Segment(C)

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html Address Book Example]</ref>

The class names for the present scenario are 

User 
AddressBook 
FileSystem 
AddressBookController 
Person 
AddressBookGUI 

The responsibilities of some of the classes and their collaborators are 
'''Person''' 
Responsibilities 
*Create a new object,given an individual's name,address,city,state,ZIP, and phone 
*Furnish the individual's first name 
*Furnish the individual's last name 
*Furnish the individual's address 
*Update the stored information(except the name) about an individual 

There are no collaborators for this class 

'''File System''' 
Responsibilities 
Read a stored address book from a file,given its file name 
Save an adddress book to a file,given its file name 

The collaborator for both the responsibilities is 
AddressBook 

== Example 3: Course Registration ==
''Requirements for the Course Registration System'' 
* The mission is to automate registration of students for courses at a university. 
* Each ''student'' takes one or more courses, which are identified by name and course number. 
* Each ''course'' is worth one or more ''credit hours''. 
* A student can register for up to 21 credit hours. 
* For each course that is taught, the students are placed into ''sections'', which may meet at different times and be taught by different instructors. 
* If more than 50 students want to take the same ''class'', another section will be added. 
* If fewer than 5 students register for a section, it will be canceled. 
* If no ''instructor'' can be persuaded (or hired) to teach a class, it will be canceled. 
* Students may specify alternate courses or sections, in case of a time ''conflict'', or if their first-choice class is canceled. 
* After a student has registered for courses, (s)he will be e-mailed a class ''schedule''. 

Some class names for the present scenario are 

Instructor 
Student 
schedule 
class 
Course 

Some of the responsibilities of the Customer class and their collaborators are

Instructor(C) offer course(sections)(R)

Student(C) takesCourse(R) Course(Colloborators)

== Example 4: Other Example ==
''Requirements for the bus navigator system'': 
* The mission is to allow ''students'' to plan trips around NCSU and Raleigh by bus. 
* Each ''rider'' specifies an origination ''stop'' and a destination ''stop'' . 
* The system presents a list of departure times, arrival times, and transfer points, and a ''map'' of the ''trip''. 
* Each item on the list consists of one or more of trip ''segments''. 
* Each trip segment consists of a ''departure point'' and ''time'', and an ''arrival point'' and ''time''. 
* If it would significantly reduce the time of the trip, the system may suggest ''walking'' between two nearby stops. 
* Each segment may be on a ''Wolfline bus'', a ''CAT bus'', or a ''TTA bus''. 
* Each bus has a ''schedule'', which is a set of ''trips'', with each trip consisting of a set of ''stops'' and ''times''. 
* The ''fare'' is 0 on a Wolfline bus, $1 on a CAT bus, and $2 ($2.50 for express) on a TTA bus. 
* The system calculates the total ''cost'' of the trip by adding the cost of the individual segments. 

The class names for the present scenario are 
stop 
map 
segment 
walk 
bus 
Trip 

The responsibilities of the Trip class and their collaborators are 
Know your Stops(R)
Know your Stopping Times(R)

Stop(C)

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T20:40:08Z

Sgurram: /* Example 4: Other Example */

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T20:39:46Z

Sgurram: /* Example 4: Other Example */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

Some class names for the present scenario are 

Customer 
Flight 
Airport 
Segment 
Ticket 
Cost 

Some nouns that are not classes are 

Seats 
Alternate Flights 
Outbound Flight 
Inbound Flight 

Some of the responsibilities of the Customer class and their collaborators are 
* to make payment(R) shopping cart(C)
* to choose the flight(R) Flight Segment(C)

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html Address Book Example]</ref>

The class names for the present scenario are 

User 
AddressBook 
FileSystem 
AddressBookController 
Person 
AddressBookGUI 

The responsibilities of some of the classes and their collaborators are 
'''Person''' 
Responsibilities 
*Create a new object,given an individual's name,address,city,state,ZIP, and phone 
*Furnish the individual's first name 
*Furnish the individual's last name 
*Furnish the individual's address 
*Update the stored information(except the name) about an individual 

There are no collaborators for this class 

'''File System''' 
Responsibilities 
Read a stored address book from a file,given its file name 
Save an adddress book to a file,given its file name 

The collaborator for both the responsibilities is 
AddressBook 

== Example 3: Course Registration ==
''Requirements for the Course Registration System'' 
* The mission is to automate registration of students for courses at a university. 
* Each ''student'' takes one or more courses, which are identified by name and course number. 
* Each ''course'' is worth one or more ''credit hours''. 
* A student can register for up to 21 credit hours. 
* For each course that is taught, the students are placed into ''sections'', which may meet at different times and be taught by different instructors. 
* If more than 50 students want to take the same ''class'', another section will be added. 
* If fewer than 5 students register for a section, it will be canceled. 
* If no ''instructor'' can be persuaded (or hired) to teach a class, it will be canceled. 
* Students may specify alternate courses or sections, in case of a time ''conflict'', or if their first-choice class is canceled. 
* After a student has registered for courses, (s)he will be e-mailed a class ''schedule''. 

Some class names for the present scenario are 

Instructor 
Student 
schedule 
class 
Course 

Some of the responsibilities of the Customer class and their collaborators are

Instructor(C) offer course(sections)(R)

Student(C) takesCourse(R) Course(Colloborators)

== Example 4: Other Example ==
''Requirements for the bus navigator system'': 
* The mission is to allow ''students'' to plan trips around NCSU and Raleigh by bus. 
* Each ''rider'' specifies an origination ''stop'' and a destination ''stop'' . 
* The system presents a list of departure times, arrival times, and transfer points, and a ''map'' of the ''trip''. 
* Each item on the list consists of one or more of trip ''segments''. 
* Each trip segment consists of a ''departure point'' and ''time'', and an ''arrival point'' and ''time''. 
* If it would significantly reduce the time of the trip, the system may suggest ''walking'' between two nearby stops. 
* Each segment may be on a ''Wolfline bus'', a ''CAT bus'', or a ''TTA bus''. 
* Each bus has a ''schedule'', which is a set of ''trips'', with each trip consisting of a set of ''stops'' and ''times''. 
* The ''fare'' is 0 on a Wolfline bus, $1 on a CAT bus, and $2 ($2.50 for express) on a TTA bus. 
* The system calculates the total ''cost'' of the trip by adding the cost of the individual segments. 

The class names for the present scenario are 
stop 
map 
segment 
walk 
bus 
Trip 

The responsibilities of the ''Trip'' class and their collaborators are 
Know your Stops(R)
Know your Stopping Times(R)

Stop(C)

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T20:39:13Z

Sgurram: /* Example 3: Course Registration */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

Some class names for the present scenario are 

Customer 
Flight 
Airport 
Segment 
Ticket 
Cost 

Some nouns that are not classes are 

Seats 
Alternate Flights 
Outbound Flight 
Inbound Flight 

Some of the responsibilities of the Customer class and their collaborators are 
* to make payment(R) shopping cart(C)
* to choose the flight(R) Flight Segment(C)

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html Address Book Example]</ref>

The class names for the present scenario are 

User 
AddressBook 
FileSystem 
AddressBookController 
Person 
AddressBookGUI 

The responsibilities of some of the classes and their collaborators are 
'''Person''' 
Responsibilities 
*Create a new object,given an individual's name,address,city,state,ZIP, and phone 
*Furnish the individual's first name 
*Furnish the individual's last name 
*Furnish the individual's address 
*Update the stored information(except the name) about an individual 

There are no collaborators for this class 

'''File System''' 
Responsibilities 
Read a stored address book from a file,given its file name 
Save an adddress book to a file,given its file name 

The collaborator for both the responsibilities is 
AddressBook 

== Example 3: Course Registration ==
''Requirements for the Course Registration System'' 
* The mission is to automate registration of students for courses at a university. 
* Each ''student'' takes one or more courses, which are identified by name and course number. 
* Each ''course'' is worth one or more ''credit hours''. 
* A student can register for up to 21 credit hours. 
* For each course that is taught, the students are placed into ''sections'', which may meet at different times and be taught by different instructors. 
* If more than 50 students want to take the same ''class'', another section will be added. 
* If fewer than 5 students register for a section, it will be canceled. 
* If no ''instructor'' can be persuaded (or hired) to teach a class, it will be canceled. 
* Students may specify alternate courses or sections, in case of a time ''conflict'', or if their first-choice class is canceled. 
* After a student has registered for courses, (s)he will be e-mailed a class ''schedule''. 

Some class names for the present scenario are 

Instructor 
Student 
schedule 
class 
Course 

Some of the responsibilities of the Customer class and their collaborators are

Instructor(C) offer course(sections)(R)

Student(C) takesCourse(R) Course(Colloborators)

== Example 4: Other Example ==
''Requirements for the bus navigator system'': 
* The mission is to allow ''students'' to plan trips around NCSU and Raleigh by bus. 
* Each ''rider'' specifies an origination ''stop'' and a destination ''stop'' . 
* The system presents a list of departure times, arrival times, and transfer points, and a ''map'' of the ''trip''. 
* Each item on the list consists of one or more of trip ''segments''. 
* Each trip segment consists of a ''departure point'' and ''time'', and an ''arrival point'' and ''time''. 
* If it would significantly reduce the time of the trip, the system may suggest ''walking'' between two nearby stops. 
* Each segment may be on a ''Wolfline bus'', a ''CAT bus'', or a ''TTA bus''. 
* Each bus has a ''schedule'', which is a set of ''trips'', with each trip consisting of a set of ''stops'' and ''times''. 
* The ''fare'' is 0 on a Wolfline bus, $1 on a CAT bus, and $2 ($2.50 for express) on a TTA bus. 
* The system calculates the total ''cost'' of the trip by adding the cost of the individual segments. 

The class names for the present scenario are 
stop 
map 
segment 
walk 
bus 
Trip 

The responsibilities of the ''Trip''classe and their collaborators are 
Know your Stops(R)
Know your Stopping Times(R)

Stop(C)

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T20:38:49Z

Sgurram: /* Example 2: Address Book */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

Some class names for the present scenario are 

Customer 
Flight 
Airport 
Segment 
Ticket 
Cost 

Some nouns that are not classes are 

Seats 
Alternate Flights 
Outbound Flight 
Inbound Flight 

Some of the responsibilities of the Customer class and their collaborators are 
* to make payment(R) shopping cart(C)
* to choose the flight(R) Flight Segment(C)

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html Address Book Example]</ref>

The class names for the present scenario are 

User 
AddressBook 
FileSystem 
AddressBookController 
Person 
AddressBookGUI 

The responsibilities of some of the classes and their collaborators are 
'''Person''' 
Responsibilities 
*Create a new object,given an individual's name,address,city,state,ZIP, and phone 
*Furnish the individual's first name 
*Furnish the individual's last name 
*Furnish the individual's address 
*Update the stored information(except the name) about an individual 

There are no collaborators for this class 

'''File System''' 
Responsibilities 
Read a stored address book from a file,given its file name 
Save an adddress book to a file,given its file name 

The collaborator for both the responsibilities is 
AddressBook 

== Example 3: Course Registration ==
''Requirements for the Course Registration System'' 
* The mission is to automate registration of students for courses at a university. 
* Each ''student'' takes one or more courses, which are identified by name and course number. 
* Each ''course'' is worth one or more ''credit hours''. 
* A student can register for up to 21 credit hours. 
* For each course that is taught, the students are placed into ''sections'', which may meet at different times and be taught by different instructors. 
* If more than 50 students want to take the same ''class'', another section will be added. 
* If fewer than 5 students register for a section, it will be canceled. 
* If no ''instructor'' can be persuaded (or hired) to teach a class, it will be canceled. 
* Students may specify alternate courses or sections, in case of a time ''conflict'', or if their first-choice class is canceled. 
* After a student has registered for courses, (s)he will be e-mailed a class ''schedule''. 

Some class names for the present scenario are 
Instructor 
Student 
schedule 
class 
Course 

Some of the responsibilities of the Customer class and their collaborators are

Instructor(C) offer course(sections)(R)

Student(C) takesCourse(R) Course(Colloborators)

== Example 4: Other Example ==
''Requirements for the bus navigator system'': 
* The mission is to allow ''students'' to plan trips around NCSU and Raleigh by bus. 
* Each ''rider'' specifies an origination ''stop'' and a destination ''stop'' . 
* The system presents a list of departure times, arrival times, and transfer points, and a ''map'' of the ''trip''. 
* Each item on the list consists of one or more of trip ''segments''. 
* Each trip segment consists of a ''departure point'' and ''time'', and an ''arrival point'' and ''time''. 
* If it would significantly reduce the time of the trip, the system may suggest ''walking'' between two nearby stops. 
* Each segment may be on a ''Wolfline bus'', a ''CAT bus'', or a ''TTA bus''. 
* Each bus has a ''schedule'', which is a set of ''trips'', with each trip consisting of a set of ''stops'' and ''times''. 
* The ''fare'' is 0 on a Wolfline bus, $1 on a CAT bus, and $2 ($2.50 for express) on a TTA bus. 
* The system calculates the total ''cost'' of the trip by adding the cost of the individual segments. 

The class names for the present scenario are 
stop 
map 
segment 
walk 
bus 
Trip 

The responsibilities of the ''Trip''classe and their collaborators are 
Know your Stops(R)
Know your Stopping Times(R)

Stop(C)

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T20:38:32Z

Sgurram: /* Example 2: Address Book */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

Some class names for the present scenario are 

Customer 
Flight 
Airport 
Segment 
Ticket 
Cost 

Some nouns that are not classes are 

Seats 
Alternate Flights 
Outbound Flight 
Inbound Flight 

Some of the responsibilities of the Customer class and their collaborators are 
* to make payment(R) shopping cart(C)
* to choose the flight(R) Flight Segment(C)

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html Address Book Example]</ref>

The class names for the present scenario are 
User 
AddressBook 
FileSystem 
AddressBookController 
Person 
AddressBookGUI 

The responsibilities of some of the classes and their collaborators are 
'''Person''' 
Responsibilities 
*Create a new object,given an individual's name,address,city,state,ZIP, and phone 
*Furnish the individual's first name 
*Furnish the individual's last name 
*Furnish the individual's address 
*Update the stored information(except the name) about an individual 

There are no collaborators for this class 

'''File System''' 
Responsibilities 
Read a stored address book from a file,given its file name 
Save an adddress book to a file,given its file name 

The collaborator for both the responsibilities is 
AddressBook 

== Example 3: Course Registration ==
''Requirements for the Course Registration System'' 
* The mission is to automate registration of students for courses at a university. 
* Each ''student'' takes one or more courses, which are identified by name and course number. 
* Each ''course'' is worth one or more ''credit hours''. 
* A student can register for up to 21 credit hours. 
* For each course that is taught, the students are placed into ''sections'', which may meet at different times and be taught by different instructors. 
* If more than 50 students want to take the same ''class'', another section will be added. 
* If fewer than 5 students register for a section, it will be canceled. 
* If no ''instructor'' can be persuaded (or hired) to teach a class, it will be canceled. 
* Students may specify alternate courses or sections, in case of a time ''conflict'', or if their first-choice class is canceled. 
* After a student has registered for courses, (s)he will be e-mailed a class ''schedule''. 

Some class names for the present scenario are 
Instructor 
Student 
schedule 
class 
Course 

Some of the responsibilities of the Customer class and their collaborators are

Instructor(C) offer course(sections)(R)

Student(C) takesCourse(R) Course(Colloborators)

== Example 4: Other Example ==
''Requirements for the bus navigator system'': 
* The mission is to allow ''students'' to plan trips around NCSU and Raleigh by bus. 
* Each ''rider'' specifies an origination ''stop'' and a destination ''stop'' . 
* The system presents a list of departure times, arrival times, and transfer points, and a ''map'' of the ''trip''. 
* Each item on the list consists of one or more of trip ''segments''. 
* Each trip segment consists of a ''departure point'' and ''time'', and an ''arrival point'' and ''time''. 
* If it would significantly reduce the time of the trip, the system may suggest ''walking'' between two nearby stops. 
* Each segment may be on a ''Wolfline bus'', a ''CAT bus'', or a ''TTA bus''. 
* Each bus has a ''schedule'', which is a set of ''trips'', with each trip consisting of a set of ''stops'' and ''times''. 
* The ''fare'' is 0 on a Wolfline bus, $1 on a CAT bus, and $2 ($2.50 for express) on a TTA bus. 
* The system calculates the total ''cost'' of the trip by adding the cost of the individual segments. 

The class names for the present scenario are 
stop 
map 
segment 
walk 
bus 
Trip 

The responsibilities of the ''Trip''classe and their collaborators are 
Know your Stops(R)
Know your Stopping Times(R)

Stop(C)

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T20:37:50Z

Sgurram: /* Example 1: Flight reservation system */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

Some class names for the present scenario are 

Customer 
Flight 
Airport 
Segment 
Ticket 
Cost 

Some nouns that are not classes are 

Seats 
Alternate Flights 
Outbound Flight 
Inbound Flight 

Some of the responsibilities of the Customer class and their collaborators are 
* to make payment(R) shopping cart(C)
* to choose the flight(R) Flight Segment(C)

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html Address Book Example]</ref>

The class names for the present scenario are 
User
AddressBook
FileSystem
AddressBookController
Person
AddressBookGUI

The responsibilities of some of the classes and their collaborators are 
'''Person''' 
Responsibilities 
*Create a new object,given an individual's name,address,city,state,ZIP, and phone 
*Furnish the individual's first name 
*Furnish the individual's last name 
*Furnish the individual's address 
*Update the stored information(except the name) about an individual 

There are no collaborators for this class 

'''File System''' 
Responsibilities 
Read a stored address book from a file,given its file name 
Save an adddress book to a file,given its file name 

The collaborator for both the responsibilities is 
AddressBook 

== Example 3: Course Registration ==
''Requirements for the Course Registration System'' 
* The mission is to automate registration of students for courses at a university. 
* Each ''student'' takes one or more courses, which are identified by name and course number. 
* Each ''course'' is worth one or more ''credit hours''. 
* A student can register for up to 21 credit hours. 
* For each course that is taught, the students are placed into ''sections'', which may meet at different times and be taught by different instructors. 
* If more than 50 students want to take the same ''class'', another section will be added. 
* If fewer than 5 students register for a section, it will be canceled. 
* If no ''instructor'' can be persuaded (or hired) to teach a class, it will be canceled. 
* Students may specify alternate courses or sections, in case of a time ''conflict'', or if their first-choice class is canceled. 
* After a student has registered for courses, (s)he will be e-mailed a class ''schedule''. 

Some class names for the present scenario are 
Instructor 
Student 
schedule 
class 
Course 

Some of the responsibilities of the Customer class and their collaborators are

Instructor(C) offer course(sections)(R)

Student(C) takesCourse(R) Course(Colloborators)

== Example 4: Other Example ==
''Requirements for the bus navigator system'': 
* The mission is to allow ''students'' to plan trips around NCSU and Raleigh by bus. 
* Each ''rider'' specifies an origination ''stop'' and a destination ''stop'' . 
* The system presents a list of departure times, arrival times, and transfer points, and a ''map'' of the ''trip''. 
* Each item on the list consists of one or more of trip ''segments''. 
* Each trip segment consists of a ''departure point'' and ''time'', and an ''arrival point'' and ''time''. 
* If it would significantly reduce the time of the trip, the system may suggest ''walking'' between two nearby stops. 
* Each segment may be on a ''Wolfline bus'', a ''CAT bus'', or a ''TTA bus''. 
* Each bus has a ''schedule'', which is a set of ''trips'', with each trip consisting of a set of ''stops'' and ''times''. 
* The ''fare'' is 0 on a Wolfline bus, $1 on a CAT bus, and $2 ($2.50 for express) on a TTA bus. 
* The system calculates the total ''cost'' of the trip by adding the cost of the individual segments. 

The class names for the present scenario are 
stop 
map 
segment 
walk 
bus 
Trip 

The responsibilities of the ''Trip''classe and their collaborators are 
Know your Stops(R)
Know your Stopping Times(R)

Stop(C)

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T20:14:23Z

Sgurram: /* Example 2: Address Book */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

Some class names for the present scenario are 

Customer 
Flight 
Airport 
Segment 
Ticket 
Cost 

Some nouns that are not classes are 
Seats 
Alternate Flights 
Outbound Flight 
Inbound Flight 

Some of the responsibilities of the Customer class and their collaborators are 
* to make payment(R) shopping cart(C)
* to choose the flight(R) Flight Segment(C)

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html Address Book Example]</ref>

The class names for the present scenario are 
User
AddressBook
FileSystem
AddressBookController
Person
AddressBookGUI

The responsibilities of some of the classes and their collaborators are 
'''Person''' 
Responsibilities 
*Create a new object,given an individual's name,address,city,state,ZIP, and phone 
*Furnish the individual's first name 
*Furnish the individual's last name 
*Furnish the individual's address 
*Update the stored information(except the name) about an individual 

There are no collaborators for this class 

'''File System''' 
Responsibilities 
Read a stored address book from a file,given its file name 
Save an adddress book to a file,given its file name 

The collaborator for both the responsibilities is 
AddressBook 

== Example 3: Course Registration ==
''Requirements for the Course Registration System'' 
* The mission is to automate registration of students for courses at a university. 
* Each ''student'' takes one or more courses, which are identified by name and course number. 
* Each ''course'' is worth one or more ''credit hours''. 
* A student can register for up to 21 credit hours. 
* For each course that is taught, the students are placed into ''sections'', which may meet at different times and be taught by different instructors. 
* If more than 50 students want to take the same ''class'', another section will be added. 
* If fewer than 5 students register for a section, it will be canceled. 
* If no ''instructor'' can be persuaded (or hired) to teach a class, it will be canceled. 
* Students may specify alternate courses or sections, in case of a time ''conflict'', or if their first-choice class is canceled. 
* After a student has registered for courses, (s)he will be e-mailed a class ''schedule''. 

Some class names for the present scenario are 
Instructor 
Student 
schedule 
class 
Course 

Some of the responsibilities of the Customer class and their collaborators are

Instructor(C) offer course(sections)(R)

Student(C) takesCourse(R) Course(Colloborators)

== Example 4: Other Example ==
''Requirements for the bus navigator system'': 
* The mission is to allow ''students'' to plan trips around NCSU and Raleigh by bus. 
* Each ''rider'' specifies an origination ''stop'' and a destination ''stop'' . 
* The system presents a list of departure times, arrival times, and transfer points, and a ''map'' of the ''trip''. 
* Each item on the list consists of one or more of trip ''segments''. 
* Each trip segment consists of a ''departure point'' and ''time'', and an ''arrival point'' and ''time''. 
* If it would significantly reduce the time of the trip, the system may suggest ''walking'' between two nearby stops. 
* Each segment may be on a ''Wolfline bus'', a ''CAT bus'', or a ''TTA bus''. 
* Each bus has a ''schedule'', which is a set of ''trips'', with each trip consisting of a set of ''stops'' and ''times''. 
* The ''fare'' is 0 on a Wolfline bus, $1 on a CAT bus, and $2 ($2.50 for express) on a TTA bus. 
* The system calculates the total ''cost'' of the trip by adding the cost of the individual segments. 

The class names for the present scenario are 
stop 
map 
segment 
walk 
bus 
Trip 

The responsibilities of the ''Trip''classe and their collaborators are 
Know your Stops(R)
Know your Stopping Times(R)

Stop(C)

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T20:03:03Z

Sgurram: /* Example 4: Other Example */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

Some class names for the present scenario are 

Customer 
Flight 
Airport 
Segment 
Ticket 
Cost 

Some nouns that are not classes are 
Seats 
Alternate Flights 
Outbound Flight 
Inbound Flight 

Some of the responsibilities of the Customer class and their collaborators are 
* to make payment(R) shopping cart(C)
* to choose the flight(R) Flight Segment(C)

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html Address Book Example]</ref>

The class names for the present scenario are 

The nouns that are not classes are 

The responsibilities of some of the classes and their collaborators are 

== Example 3: Course Registration ==
''Requirements for the Course Registration System'' 
* The mission is to automate registration of students for courses at a university. 
* Each ''student'' takes one or more courses, which are identified by name and course number. 
* Each ''course'' is worth one or more ''credit hours''. 
* A student can register for up to 21 credit hours. 
* For each course that is taught, the students are placed into ''sections'', which may meet at different times and be taught by different instructors. 
* If more than 50 students want to take the same ''class'', another section will be added. 
* If fewer than 5 students register for a section, it will be canceled. 
* If no ''instructor'' can be persuaded (or hired) to teach a class, it will be canceled. 
* Students may specify alternate courses or sections, in case of a time ''conflict'', or if their first-choice class is canceled. 
* After a student has registered for courses, (s)he will be e-mailed a class ''schedule''. 

Some class names for the present scenario are 
Instructor 
Student 
schedule 
class 
Course 

Some of the responsibilities of the Customer class and their collaborators are

Instructor(C) offer course(sections)(R)

Student(C) takesCourse(R) Course(Colloborators)

== Example 4: Other Example ==
''Requirements for the bus navigator system'': 
* The mission is to allow ''students'' to plan trips around NCSU and Raleigh by bus. 
* Each ''rider'' specifies an origination ''stop'' and a destination ''stop'' . 
* The system presents a list of departure times, arrival times, and transfer points, and a ''map'' of the ''trip''. 
* Each item on the list consists of one or more of trip ''segments''. 
* Each trip segment consists of a ''departure point'' and ''time'', and an ''arrival point'' and ''time''. 
* If it would significantly reduce the time of the trip, the system may suggest ''walking'' between two nearby stops. 
* Each segment may be on a ''Wolfline bus'', a ''CAT bus'', or a ''TTA bus''. 
* Each bus has a ''schedule'', which is a set of ''trips'', with each trip consisting of a set of ''stops'' and ''times''. 
* The ''fare'' is 0 on a Wolfline bus, $1 on a CAT bus, and $2 ($2.50 for express) on a TTA bus. 
* The system calculates the total ''cost'' of the trip by adding the cost of the individual segments. 

The class names for the present scenario are 
stop 
map 
segment 
walk 
bus 
Trip 

The responsibilities of the ''Trip''classe and their collaborators are 
Know your Stops(R)
Know your Stopping Times(R)

Stop(C)

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T19:38:51Z

Sgurram: /* Example 3: Course Registration */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

Some class names for the present scenario are 

Customer 
Flight 
Airport 
Segment 
Ticket 
Cost 

Some nouns that are not classes are 
Seats 
Alternate Flights 
Outbound Flight 
Inbound Flight 

Some of the responsibilities of the Customer class and their collaborators are 
* to make payment(R) shopping cart(C)
* to choose the flight(R) Flight Segment(C)

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html Address Book Example]</ref>

The class names for the present scenario are 

The nouns that are not classes are 

The responsibilities of some of the classes and their collaborators are 

== Example 3: Course Registration ==
''Requirements for the Course Registration System'' 
* The mission is to automate registration of students for courses at a university. 
* Each ''student'' takes one or more courses, which are identified by name and course number. 
* Each ''course'' is worth one or more ''credit hours''. 
* A student can register for up to 21 credit hours. 
* For each course that is taught, the students are placed into ''sections'', which may meet at different times and be taught by different instructors. 
* If more than 50 students want to take the same ''class'', another section will be added. 
* If fewer than 5 students register for a section, it will be canceled. 
* If no ''instructor'' can be persuaded (or hired) to teach a class, it will be canceled. 
* Students may specify alternate courses or sections, in case of a time ''conflict'', or if their first-choice class is canceled. 
* After a student has registered for courses, (s)he will be e-mailed a class ''schedule''. 

Some class names for the present scenario are 
Instructor 
Student 
schedule 
class 
Course 

Some of the responsibilities of the Customer class and their collaborators are

Instructor(C) offer course(sections)(R)

Student(C) takesCourse(R) Course(Colloborators)

== Example 4: Other Example ==
''Requirements for the bus navigator system'': 
* The mission is to allow ''students'' to plan trips around NCSU and Raleigh by bus. 
* Each ''rider'' specifies an origination ''stop'' and a destination ''stop'' . 
* The system presents a list of departure times, arrival times, and transfer points, and a ''map'' of the ''trip''. 
* Each item on the list consists of one or more of trip ''segments''. 
* Each trip segment consists of a ''departure point'' and ''time'', and an ''arrival point'' and ''time''. 
* If it would significantly reduce the time of the trip, the system may suggest ''walking'' between two nearby stops. 
* Each segment may be on a ''Wolfline bus'', a ''CAT bus'', or a ''TTA bus''. 
* Each bus has a ''schedule'', which is a set of ''trips'', with each trip consisting of a set of ''stops'' and ''times''. 
* The ''fare'' is 0 on a Wolfline bus, $1 on a CAT bus, and $2 ($2.50 for express) on a TTA bus. 
* The system calculates the total ''cost'' of the trip by adding the cost of the individual segments. 

The class names for the present scenario are 

The nouns that are not classes are 

The responsibilities of some of the classes and their collaborators are 

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T18:58:19Z

Sgurram: /* Example 3: Course Registration */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

Some class names for the present scenario are 

Customer 
Flight 
Airport 
Segment 
Ticket 
Cost 

Some nouns that are not classes are 
Seats 
Alternate Flights 
Outbound Flight 
Inbound Flight 

Some of the responsibilities of the Customer class and their collaborators are 
* to make payment(R) shopping cart(C)
* to choose the flight(R) Flight Segment(C)

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html Address Book Example]</ref>

The class names for the present scenario are 

The nouns that are not classes are 

The responsibilities of some of the classes and their collaborators are 

== Example 3: Course Registration ==
''Requirements for the Course Registration System'' 
* The mission is to automate registration of students for courses at a university. 
* Each ''student'' takes one or more courses, which are identified by name and course number. 
* Each ''course'' is worth one or more ''credit hours''. 
* A student can register for up to 21 credit hours. 
* For each course that is taught, the students are placed into ''sections'', which may meet at different times and be taught by different instructors. 
* If more than 50 students want to take the same ''class'', another section will be added. 
* If fewer than 5 students register for a section, it will be canceled. 
* If no ''instructor'' can be persuaded (or hired) to teach a class, it will be canceled. 
* Students may specify alternate courses or sections, in case of a time ''conflict'', or if their first-choice class is canceled. 
* After a student has registered for courses, (s)he will be e-mailed a class ''schedule''. 

Some class names for the present scenario are 
Instructor 
Student 
schedule 
class 
Course 

Some of the responsibilities of the Customer class and their collaborators are

== Example 4: Other Example ==
''Requirements for the bus navigator system'': 
* The mission is to allow ''students'' to plan trips around NCSU and Raleigh by bus. 
* Each ''rider'' specifies an origination ''stop'' and a destination ''stop'' . 
* The system presents a list of departure times, arrival times, and transfer points, and a ''map'' of the ''trip''. 
* Each item on the list consists of one or more of trip ''segments''. 
* Each trip segment consists of a ''departure point'' and ''time'', and an ''arrival point'' and ''time''. 
* If it would significantly reduce the time of the trip, the system may suggest ''walking'' between two nearby stops. 
* Each segment may be on a ''Wolfline bus'', a ''CAT bus'', or a ''TTA bus''. 
* Each bus has a ''schedule'', which is a set of ''trips'', with each trip consisting of a set of ''stops'' and ''times''. 
* The ''fare'' is 0 on a Wolfline bus, $1 on a CAT bus, and $2 ($2.50 for express) on a TTA bus. 
* The system calculates the total ''cost'' of the trip by adding the cost of the individual segments. 

The class names for the present scenario are 

The nouns that are not classes are 

The responsibilities of some of the classes and their collaborators are 

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T18:26:09Z

Sgurram: /* Example 1: Flight reservation system */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

Some class names for the present scenario are 

Customer 
Flight 
Airport 
Segment 
Ticket 
Cost 

Some nouns that are not classes are 
Seats 
Alternate Flights 
Outbound Flight 
Inbound Flight 

Some of the responsibilities of the Customer class and their collaborators are 
* to make payment(R) shopping cart(C)
* to choose the flight(R) Flight Segment(C)

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html Address Book Example]</ref>

The class names for the present scenario are 

The nouns that are not classes are 

The responsibilities of some of the classes and their collaborators are 

== Example 3: Course Registration ==
''Requirements for the Course Registration System'' 
* The mission is to automate registration of students for courses at a university. 
* Each ''student'' takes one or more courses, which are identified by name and course number. 
* Each ''course'' is worth one or more ''credit hours''. 
* A student can register for up to 21 credit hours. 
* For each course that is taught, the students are placed into ''sections'', which may meet at different times and be taught by different instructors. 
* If more than 50 students want to take the same ''class'', another section will be added. 
* If fewer than 5 students register for a section, it will be canceled. 
* If no ''instructor'' can be persuaded (or hired) to teach a class, it will be canceled. 
* Students may specify alternate courses or sections, in case of a time ''conflict'', or if their first-choice class is canceled. 
* After a student has registered for courses, (s)he will be e-mailed a class ''schedule''. 

The class names for the present scenario are 

The nouns that are not classes are 

The responsibilities of some of the classes and their collaborators are 

== Example 4: Other Example ==
''Requirements for the bus navigator system'': 
* The mission is to allow ''students'' to plan trips around NCSU and Raleigh by bus. 
* Each ''rider'' specifies an origination ''stop'' and a destination ''stop'' . 
* The system presents a list of departure times, arrival times, and transfer points, and a ''map'' of the ''trip''. 
* Each item on the list consists of one or more of trip ''segments''. 
* Each trip segment consists of a ''departure point'' and ''time'', and an ''arrival point'' and ''time''. 
* If it would significantly reduce the time of the trip, the system may suggest ''walking'' between two nearby stops. 
* Each segment may be on a ''Wolfline bus'', a ''CAT bus'', or a ''TTA bus''. 
* Each bus has a ''schedule'', which is a set of ''trips'', with each trip consisting of a set of ''stops'' and ''times''. 
* The ''fare'' is 0 on a Wolfline bus, $1 on a CAT bus, and $2 ($2.50 for express) on a TTA bus. 
* The system calculates the total ''cost'' of the trip by adding the cost of the individual segments. 

The class names for the present scenario are 

The nouns that are not classes are 

The responsibilities of some of the classes and their collaborators are 

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T17:46:15Z

Sgurram: /* Example 3: Course Registration */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

The class names for the present scenario are 

The nouns that are not classes are 

The responsibilities of some of the classes and their collaborators are 

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html Address Book Example]</ref>

The class names for the present scenario are 

The nouns that are not classes are 

The responsibilities of some of the classes and their collaborators are 

== Example 3: Course Registration ==
''Requirements for the Course Registration System'' 
* The mission is to automate registration of students for courses at a university. 
* Each ''student'' takes one or more courses, which are identified by name and course number. 
* Each ''course'' is worth one or more ''credit hours''. 
* A student can register for up to 21 credit hours. 
* For each course that is taught, the students are placed into ''sections'', which may meet at different times and be taught by different instructors. 
* If more than 50 students want to take the same ''class'', another section will be added. 
* If fewer than 5 students register for a section, it will be canceled. 
* If no ''instructor'' can be persuaded (or hired) to teach a class, it will be canceled. 
* Students may specify alternate courses or sections, in case of a time ''conflict'', or if their first-choice class is canceled. 
* After a student has registered for courses, (s)he will be e-mailed a class ''schedule''. 

The class names for the present scenario are 

The nouns that are not classes are 

The responsibilities of some of the classes and their collaborators are 

== Example 4: Other Example ==
''Requirements for the bus navigator system'': 
* The mission is to allow ''students'' to plan trips around NCSU and Raleigh by bus. 
* Each ''rider'' specifies an origination ''stop'' and a destination ''stop'' . 
* The system presents a list of departure times, arrival times, and transfer points, and a ''map'' of the ''trip''. 
* Each item on the list consists of one or more of trip ''segments''. 
* Each trip segment consists of a ''departure point'' and ''time'', and an ''arrival point'' and ''time''. 
* If it would significantly reduce the time of the trip, the system may suggest ''walking'' between two nearby stops. 
* Each segment may be on a ''Wolfline bus'', a ''CAT bus'', or a ''TTA bus''. 
* Each bus has a ''schedule'', which is a set of ''trips'', with each trip consisting of a set of ''stops'' and ''times''. 
* The ''fare'' is 0 on a Wolfline bus, $1 on a CAT bus, and $2 ($2.50 for express) on a TTA bus. 
* The system calculates the total ''cost'' of the trip by adding the cost of the individual segments. 

The class names for the present scenario are 

The nouns that are not classes are 

The responsibilities of some of the classes and their collaborators are 

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T17:45:33Z

Sgurram: /* Example 4: Other Example */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

The class names for the present scenario are 

The nouns that are not classes are 

The responsibilities of some of the classes and their collaborators are 

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html Address Book Example]</ref>

The class names for the present scenario are 

The nouns that are not classes are 

The responsibilities of some of the classes and their collaborators are 

== Example 3: Course Registration ==
''Requirements for the Course Registration System'' 
* The mission is to automate registration of students for courses at a university. 
* Each ''student'' takes one or more courses, which are identified by name and course number. 
* Each ''course'' is worth one or more ''credit hours''. 
* A student can register for up to 21 credit hours. 
* For each course that is taught, the students are placed into ''sections'', which may meet at different times and be taught by different instructors. 
* If more than 50 students want to take the same ''class'', another section will be added. 
* If fewer than 5 students register for a section, it will be canceled. 
* If no ''instructor'' can be persuaded (or hired) to teach a class, it will be canceled. 
* Students may specify alternate courses or sections, in case of a time ''conflict'', or if their first-choice class is canceled. 
* After a student has registered for courses, (s)he will be e-mailed a class ''schedule''. 

== Example 4: Other Example ==
''Requirements for the bus navigator system'': 
* The mission is to allow ''students'' to plan trips around NCSU and Raleigh by bus. 
* Each ''rider'' specifies an origination ''stop'' and a destination ''stop'' . 
* The system presents a list of departure times, arrival times, and transfer points, and a ''map'' of the ''trip''. 
* Each item on the list consists of one or more of trip ''segments''. 
* Each trip segment consists of a ''departure point'' and ''time'', and an ''arrival point'' and ''time''. 
* If it would significantly reduce the time of the trip, the system may suggest ''walking'' between two nearby stops. 
* Each segment may be on a ''Wolfline bus'', a ''CAT bus'', or a ''TTA bus''. 
* Each bus has a ''schedule'', which is a set of ''trips'', with each trip consisting of a set of ''stops'' and ''times''. 
* The ''fare'' is 0 on a Wolfline bus, $1 on a CAT bus, and $2 ($2.50 for express) on a TTA bus. 
* The system calculates the total ''cost'' of the trip by adding the cost of the individual segments. 

The class names for the present scenario are 

The nouns that are not classes are 

The responsibilities of some of the classes and their collaborators are 

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T17:45:17Z

Sgurram: /* Example 2: Address Book */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

The class names for the present scenario are 

The nouns that are not classes are 

The responsibilities of some of the classes and their collaborators are 

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html Address Book Example]</ref>

The class names for the present scenario are 

The nouns that are not classes are 

The responsibilities of some of the classes and their collaborators are 

== Example 3: Course Registration ==
''Requirements for the Course Registration System'' 
* The mission is to automate registration of students for courses at a university. 
* Each ''student'' takes one or more courses, which are identified by name and course number. 
* Each ''course'' is worth one or more ''credit hours''. 
* A student can register for up to 21 credit hours. 
* For each course that is taught, the students are placed into ''sections'', which may meet at different times and be taught by different instructors. 
* If more than 50 students want to take the same ''class'', another section will be added. 
* If fewer than 5 students register for a section, it will be canceled. 
* If no ''instructor'' can be persuaded (or hired) to teach a class, it will be canceled. 
* Students may specify alternate courses or sections, in case of a time ''conflict'', or if their first-choice class is canceled. 
* After a student has registered for courses, (s)he will be e-mailed a class ''schedule''. 

== Example 4: Other Example ==
''Requirements for the bus navigator system'': 
* The mission is to allow ''students'' to plan trips around NCSU and Raleigh by bus. 
* Each ''rider'' specifies an origination ''stop'' and a destination ''stop'' . 
* The system presents a list of departure times, arrival times, and transfer points, and a ''map'' of the ''trip''. 
* Each item on the list consists of one or more of trip ''segments''. 
* Each trip segment consists of a ''departure point'' and ''time'', and an ''arrival point'' and ''time''. 
* If it would significantly reduce the time of the trip, the system may suggest ''walking'' between two nearby stops. 
* Each segment may be on a ''Wolfline bus'', a ''CAT bus'', or a ''TTA bus''. 
* Each bus has a ''schedule'', which is a set of ''trips'', with each trip consisting of a set of ''stops'' and ''times''. 
* The ''fare'' is 0 on a Wolfline bus, $1 on a CAT bus, and $2 ($2.50 for express) on a TTA bus. 
* The system calculates the total ''cost'' of the trip by adding the cost of the individual segments. 

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T17:45:00Z

Sgurram: /* Example 1: Flight reservation system */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

The class names for the present scenario are 

The nouns that are not classes are 

The responsibilities of some of the classes and their collaborators are 

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html Address Book Example]</ref>

== Example 3: Course Registration ==
''Requirements for the Course Registration System'' 
* The mission is to automate registration of students for courses at a university. 
* Each ''student'' takes one or more courses, which are identified by name and course number. 
* Each ''course'' is worth one or more ''credit hours''. 
* A student can register for up to 21 credit hours. 
* For each course that is taught, the students are placed into ''sections'', which may meet at different times and be taught by different instructors. 
* If more than 50 students want to take the same ''class'', another section will be added. 
* If fewer than 5 students register for a section, it will be canceled. 
* If no ''instructor'' can be persuaded (or hired) to teach a class, it will be canceled. 
* Students may specify alternate courses or sections, in case of a time ''conflict'', or if their first-choice class is canceled. 
* After a student has registered for courses, (s)he will be e-mailed a class ''schedule''. 

== Example 4: Other Example ==
''Requirements for the bus navigator system'': 
* The mission is to allow ''students'' to plan trips around NCSU and Raleigh by bus. 
* Each ''rider'' specifies an origination ''stop'' and a destination ''stop'' . 
* The system presents a list of departure times, arrival times, and transfer points, and a ''map'' of the ''trip''. 
* Each item on the list consists of one or more of trip ''segments''. 
* Each trip segment consists of a ''departure point'' and ''time'', and an ''arrival point'' and ''time''. 
* If it would significantly reduce the time of the trip, the system may suggest ''walking'' between two nearby stops. 
* Each segment may be on a ''Wolfline bus'', a ''CAT bus'', or a ''TTA bus''. 
* Each bus has a ''schedule'', which is a set of ''trips'', with each trip consisting of a set of ''stops'' and ''times''. 
* The ''fare'' is 0 on a Wolfline bus, $1 on a CAT bus, and $2 ($2.50 for express) on a TTA bus. 
* The system calculates the total ''cost'' of the trip by adding the cost of the individual segments. 

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T14:34:44Z

Sgurram: /* Example 4: Other Example */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html Address Book Example]</ref>

== Example 3: Course Registration ==
''Requirements for the Course Registration System'' 
* The mission is to automate registration of students for courses at a university. 
* Each ''student'' takes one or more courses, which are identified by name and course number. 
* Each ''course'' is worth one or more ''credit hours''. 
* A student can register for up to 21 credit hours. 
* For each course that is taught, the students are placed into ''sections'', which may meet at different times and be taught by different instructors. 
* If more than 50 students want to take the same ''class'', another section will be added. 
* If fewer than 5 students register for a section, it will be canceled. 
* If no ''instructor'' can be persuaded (or hired) to teach a class, it will be canceled. 
* Students may specify alternate courses or sections, in case of a time ''conflict'', or if their first-choice class is canceled. 
* After a student has registered for courses, (s)he will be e-mailed a class ''schedule''. 

== Example 4: Other Example ==
''Requirements for the bus navigator system'': 
* The mission is to allow ''students'' to plan trips around NCSU and Raleigh by bus. 
* Each ''rider'' specifies an origination ''stop'' and a destination ''stop'' . 
* The system presents a list of departure times, arrival times, and transfer points, and a ''map'' of the ''trip''. 
* Each item on the list consists of one or more of trip ''segments''. 
* Each trip segment consists of a ''departure point'' and ''time'', and an ''arrival point'' and ''time''. 
* If it would significantly reduce the time of the trip, the system may suggest ''walking'' between two nearby stops. 
* Each segment may be on a ''Wolfline bus'', a ''CAT bus'', or a ''TTA bus''. 
* Each bus has a ''schedule'', which is a set of ''trips'', with each trip consisting of a set of ''stops'' and ''times''. 
* The ''fare'' is 0 on a Wolfline bus, $1 on a CAT bus, and $2 ($2.50 for express) on a TTA bus. 
* The system calculates the total ''cost'' of the trip by adding the cost of the individual segments. 

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T14:12:29Z

Sgurram: /* Example 3: Course Registration */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html Address Book Example]</ref>

== Example 3: Course Registration ==
''Requirements for the Course Registration System'' 
* The mission is to automate registration of students for courses at a university. 
* Each ''student'' takes one or more courses, which are identified by name and course number. 
* Each ''course'' is worth one or more ''credit hours''. 
* A student can register for up to 21 credit hours. 
* For each course that is taught, the students are placed into ''sections'', which may meet at different times and be taught by different instructors. 
* If more than 50 students want to take the same ''class'', another section will be added. 
* If fewer than 5 students register for a section, it will be canceled. 
* If no ''instructor'' can be persuaded (or hired) to teach a class, it will be canceled. 
* Students may specify alternate courses or sections, in case of a time ''conflict'', or if their first-choice class is canceled. 
* After a student has registered for courses, (s)he will be e-mailed a class ''schedule''. 

== Example 4: Other Example ==

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T14:04:16Z

Sgurram: /* Example 2: Address Book */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html Address Book Example]</ref>

== Example 3: Course Registration ==

== Example 4: Other Example ==

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T14:03:18Z

Sgurram: /* Example 2: Address Book */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.<ref name="Address Book Example">[http://www.cs.gordon.edu/courses/cs211/AddressBookExample/Requirements.html]</ref>

== Example 3: Course Registration ==

== Example 4: Other Example ==

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T14:00:47Z

Sgurram: /* Example 2: Address Book */

='''Introduction to Object Oriented Design(OOD)'''=

This page serves as a knowledge source for understanding the concepts covered in Lecture14- [http://en.wikipedia.org/wiki/Object-oriented_design Introduction to Object Oriented Design(OOD)]. 

__TOC__

= Overview =
Lecture 14 <ref name="CSC517">[http://courses.ncsu.edu/csc517//common/lectures/notes/lec14.pdf OOD], CSC 517 Lecture14</ref> of CSC 517 covered various aspects of the [http://en.wikipedia.org/wiki/Object-oriented_design object oriented design] including the basics of OOD principles along with the design criteria and the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class Responsibility Collaboration card] tool.

Object-oriented design can be defined as the process of planning a 'system of interacting objects' for the purpose of solving a software problem. It is one approach to software design that revolves around the basic entity called [http://en.wikipedia.org/wiki/Object_(computer_science) object]. An object contains data and procedures grouped together to represent an entity(class). Object-oriented design is the discipline of defining the objects and their interactions to solve a problem that was identified and documented during object-oriented analysis.

= Basic Object Oriented Concepts =
The five basic concepts of object-oriented design are the implementation level features that are built into the programming language. They can be considered as the general vocabulary required to implement an object oriented design solution <ref name="OOD vocabulary">[http://www.beroux.com/english/articles/oop_uml_and_rup.php OOD Vocabulary], OOD Vocabulary</ref>. These terms are explained in brief:

*[http://en.wikipedia.org/wiki/Object_(computer_science) Object]: A ''class'' is a tight coupling or association of data structures with the methods or functions that act on the data. An ''object'' is an instance of the class serving a separate function. An object is defined by its properties.

*[http://en.wikipedia.org/wiki/Information_hiding Information Hiding/Encapsulation]: The ability to protect some components of the object from external entities i.e. protecting parts of the program from extensive modification if the design decision is changed. This is achieved by language keywords to enable a variable to be declared as ''private'' or ''protected'' to the owning ''class''.

*[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance]: inheritance is a way to reuse code of existing objects and thus ability for a ''class'' to extend or override functionality of another ''class''. Inheritance is realized by establishing a subtype from an existing object, or both, depending upon programming language support.

*[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism]: The ability to replace an ''object'' with its ''subobjects''. The ability of an ''object-variable'' to contain, not only that ''object'', but also all of its ''subobjects''.

*[http://en.wikipedia.org/wiki/Interface_(computer_science) Interface]: Interface can be defined as the ability to defer the implementation of a ''method'' or the process to define the ''functions'' or ''methods'' signatures without implementing them.

= Criteria for Elegant Software Design =
Listed below are the different criteria for elegant software design. There are nine different design considerations, out of which the first five address correctness of the software and the rest consider the performance.

[http://en.wikipedia.org/wiki/Usability Usability]: Usability can be measured by the ease of use for the client.

'''Completeness''': A software program/application is complete if it solves all the client needs.

'''Robustness''': A good design is one that can deal with unusual situations gracefully and avoid crashing.

'''Efficiency''': The application performs the necessary computations in a reasonable amount of time.

'''Scalability''': An application is scalable if it performs correctly and efficiently when the problems grow in size by several orders of magnitude.

'''Readability''': If it is easy for another programmer to read and understand the design and code, the design is readable.

'''Modifiability''': If the software can easily be enhanced or restricted by adding new features or removing old features without breaking existing code, the design is modifiable.

'''Reusability''': Resuability checks the ability to be reused in another completely different setting.

'''Simplicity''': The simplicity criteria check if the design and/or the implementation unnecessarily complex.

= Design Concepts =
Listed below are the major components for building a design solution for a problem:
* Defining objects, creating [http://en.wikipedia.org/wiki/Class_diagram class diagram] from conceptual models and map the entities to classes.

* Identifying attributes for each class/entity.

* Use [http://en.wikipedia.org/wiki/Design_pattern_(computer_science) design patterns] <ref name="Design Patterns">[http://www.uml.org.cn/c++/pdf/DesignPatterns.pdf Design Patterns Elements of Reusable Object Oriented Software by Erich Gamma]</ref> to solve a problem that can be used in many different situations and/or applications.

* Identifying persistent objects i.e. to know objects that last longer than a single runtime.

* Identify the [http://en.wikipedia.org/wiki/Application_framework application framework] to take advantage of the existing code and reuse whatever possible.

=Design Principles =
Listed below are the main principles that need to be followed for building an effective design solution<ref name="Design Principles">[http://www.oodesign.com/design-principles.html Object Oriented Design Principles]</ref>:

* [http://en.wikipedia.org/wiki/Open/closed_principle Open Close Principle]: This principle states that software entities like classes, modules and functions should be open for extension but closed for modifications.

* [http://en.wikipedia.org/wiki/Dependency_inversion_principle Dependency Inversion Principle]: This principle states that high-level modules should not depend on low-level modules and both should depend on abstractions.

* [http://en.wikipedia.org/wiki/Interface_segregation_principle Interface Segregation Principle]: This principle states that clients should not be forced to depend upon interfaces that they do not use.

* [http://en.wikipedia.org/wiki/Single_responsibility_principle Single Responsibility Principle]: This principle states that a class should have only reason to change.

* [http://en.wikipedia.org/wiki/Liskov_substitution_principle Liskov's Substitution Principle]: This principle states that derived types must be completely substitutable for their base types.

= OOD: The CRC Method =
[http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card Class-Responsibility-Collaboration card] is a very useful tool for software design that determine the [http://en.wikipedia.org/wiki/Class-Responsibility-Collaboration_card classes] needed along with the types of interactions.

CRC cards are created from [http://en.wikipedia.org/wiki/Index_card index card]s on which are written:

# The class name
# Its Super and Sub classes (if applicable)
# The responsibilities of the class.
# The names of other classes with which the class will collaborate to fulfill its responsibilities.
# Author

The use of small card minimizes the complexity of the design. It forces the designer to refrain from giving the class too many responsibilities. These cards are portable and thus can easily be laid out on a table and re-arranged while discussing the design with other people.

A specification for the program being designed is studied and then the cards that need to be created are designed. The cards contain the class names(generally nouns) along with the responsibilities(verbs) and the collaborators associated with the class. When choosing classes, we need to make sure that the class name,

#is a singular noun,
#does not really have the same functionality as some other class,
#is not simply a primitive type,(because u need not write code for primitive types)

== Example 1: Flight reservation system ==

''Requirements for the Flight Reservation System '' 
* The mission is to allow round-trip airline ''tickets'' to be bought over the Web. 
* Each ''customer'' specifies an origination ''airport'', a destination airport, and dates for outbound and return ''flights''. 
* The customer reserves one ''outbound flight'' and one ''return flight'' from a menu presented by the system. 
* Each choice that the system presents consists of one or more flight ''segments'' (there may be a change of planes). 
* The customer may buy tickets for one or more ''passengers''. 
* No more tickets can be sold for a flight than there are ''seats'' on the ''plane''. 
* Each passenger is assigned to a specific seat. 
* The system calculates the total ''cost'' of the tickets by adding the cost of the individual segments. 
*If dissatisfied with the cost, the customer may select ''alternate flights''. 
* After a customer has bought a ticket, (s)he will be e-mailed a ''confirmation'' 

== Example 2: Address Book ==
Requirements Statements 
The software to be designed is a program that can be used to maintain an address book. An address book holds a collection of entries, each recording a person's first and last names, address, city, state, zip, and phone number.

It must be possible to add a new person to an address book, to edit existing information about a person (except the person's name), and to delete a person. It must be possible to sort the entries in the address book alphabetically by last name (with ties broken by first name if necessary), or by ZIP code (with ties broken by name if necessary). It must be possible to print out all the entries in the address book in "mailing label" format.

It must be possible to create a new address book, to open a disk file containing an existing address book to close an address book, and to save an address book to a disk file, using standard New, Open, Close, Save and Save As ... File menu options. The program's File menu will also have a Quit option to allow closing all open address books and terminating the program.

The initial requirements call for the program to only be able to work with a single address book at a time; therefore, if the user chooses the New or Open menu option, any current address book will be closed before creating/opening a new one. A later extension might allow for multiple address books to be open, each with its own window which can be closed separately, with closing the last open window resulting in terminating the program. In this case, New and Open will result in creating a new window, without affecting the current window.

The program will keep track of whether any changes have been made to an address book since it was last saved, and will offer the user the opportunity to save changes when an address book is closed either explicitly or as a result of choosing to create/open another or to quit the program.

The program will keep track of the file that the current address book was read from or most recently saved to, will display the file's name as the title of the main window, and will use that file when executing the Save option. When a New address book is initially created, its window will be titled "Untitled", and a Save operation will be converted to Save As ... - i.e. the user will be required to specify a file.

== Example 3: Course Registration ==

== Example 4: Other Example ==

= Conclusion =

=References=
<references />

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T13:55:21Z

Sgurram: /* Example 1: Flight reservation system */

CSC/ECE 517 Fall 2011/ch4 5a sp

2011-11-01T13:44:51Z

Sgurram: /* Example 1: Flight reservation system */

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-26T00:53:20Z

Sgurram: /* Scheme's way of handling */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between [http://en.wikipedia.org/wiki/Type_system#Static_typing statically] and [http://en.wikipedia.org/wiki/Type_system#Dynamic_typing dynamically] typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed.: [http://en.wikipedia.org/wiki/C_(programming_language) C],[http://en.wikipedia.org/wiki/C%2B%2B_(programming_language) C++],[http://en.wikipedia.org/wiki/Java_(programming_language) Java],[http://en.wikipedia.org/wiki/JADE_(programming_language) JADE],[http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal] etc<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref> 
Examples of Dynamically typed : [http://en.wikipedia.org/wiki/PHP PHP],[http://en.wikipedia.org/wiki/Prolog Prolog],[http://en.wikipedia.org/wiki/Python_(programming_language) Python],[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby],[http://en.wikipedia.org/wiki/Smalltalk Small talk] etc.<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''<ref>http://www.artima.com/intv/closures2.html Blocks and Closures</ref>

=== What exactly is Closure ===
*A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
<ref>http://www.codethinked.com/c-closures-explained C# Closures</ref>

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. <ref>http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby</ref>

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
<ref>http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS</ref>

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.<ref>http://ynniv.com/blog/2007/08/closures-in-python.html Closures in Python</ref>

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.<ref>http://dl.acm.org/citation.cfm?id=1026483 Guimar˜aes, Jos´e de Oliveira. "Closures for Statically-Typed Object-Oriented Languages"</ref>
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. <ref> http://en.wikipedia.org/wiki/Static_scope Static Scope</ref>
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.<ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29 Closure like implementation in C++</ref>

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. <ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java Closures like implementation in Java</ref>

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. <ref>http://en.wikipedia.org/wiki/Static_scope Static Scope</ref> Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

$arr = Array.new
def funcGen(val)
0.upto(val) do |i|
$arr[i] = Proc.new{print i}
end
end
funcGen(4)
$arr.each do |val|
val.call
end

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. <ref>http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx C# Anonymous methods</ref>

===Scheme's way of handling===

[http://en.wikipedia.org/wiki/Scheme_(programming_language) Scheme] is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.<ref>http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope Scheme </ref>

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
<ref>http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work Closures in scheme </ref>

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-26T00:49:24Z

Sgurram: /* What exactly is Closure */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between [http://en.wikipedia.org/wiki/Type_system#Static_typing statically] and [http://en.wikipedia.org/wiki/Type_system#Dynamic_typing dynamically] typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed.: [http://en.wikipedia.org/wiki/C_(programming_language) C],[http://en.wikipedia.org/wiki/C%2B%2B_(programming_language) C++],[http://en.wikipedia.org/wiki/Java_(programming_language) Java],[http://en.wikipedia.org/wiki/JADE_(programming_language) JADE],[http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal] etc<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref> 
Examples of Dynamically typed : [http://en.wikipedia.org/wiki/PHP PHP],[http://en.wikipedia.org/wiki/Prolog Prolog],[http://en.wikipedia.org/wiki/Python_(programming_language) Python],[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby],[http://en.wikipedia.org/wiki/Smalltalk Small talk] etc.<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''<ref>http://www.artima.com/intv/closures2.html Blocks and Closures</ref>

=== What exactly is Closure ===
*A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
<ref>http://www.codethinked.com/c-closures-explained C# Closures</ref>

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. <ref>http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby</ref>

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
<ref>http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS</ref>

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.<ref>http://ynniv.com/blog/2007/08/closures-in-python.html Closures in Python</ref>

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.<ref>http://dl.acm.org/citation.cfm?id=1026483 Guimar˜aes, Jos´e de Oliveira. "Closures for Statically-Typed Object-Oriented Languages"</ref>
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. <ref> http://en.wikipedia.org/wiki/Static_scope Static Scope</ref>
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.<ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29 Closure like implementation in C++</ref>

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. <ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java Closures like implementation in Java</ref>

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. <ref>http://en.wikipedia.org/wiki/Static_scope Static Scope</ref> Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

$arr = Array.new
def funcGen(val)
0.upto(val) do |i|
$arr[i] = Proc.new{print i}
end
end
funcGen(4)
$arr.each do |val|
val.call
end

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. <ref>http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx C# Anonymous methods</ref>

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.<ref>http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope Scheme </ref>

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
<ref>http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work Closures in scheme </ref>

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-26T00:46:33Z

Sgurram: /* Statically vs Dynamically typed */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between [http://en.wikipedia.org/wiki/Type_system#Static_typing statically] and [http://en.wikipedia.org/wiki/Type_system#Dynamic_typing dynamically] typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed.: [http://en.wikipedia.org/wiki/C_(programming_language) C],[http://en.wikipedia.org/wiki/C%2B%2B_(programming_language) C++],[http://en.wikipedia.org/wiki/Java_(programming_language) Java],[http://en.wikipedia.org/wiki/JADE_(programming_language) JADE],[http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal] etc<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref> 
Examples of Dynamically typed : [http://en.wikipedia.org/wiki/PHP PHP],[http://en.wikipedia.org/wiki/Prolog Prolog],[http://en.wikipedia.org/wiki/Python_(programming_language) Python],[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby],[http://en.wikipedia.org/wiki/Smalltalk Small talk] etc.<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''<ref>http://www.artima.com/intv/closures2.html Blocks and Closures</ref>

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
<ref>http://www.codethinked.com/c-closures-explained C# Closures</ref>

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. <ref>http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby</ref>

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
<ref>http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS</ref>

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.<ref>http://ynniv.com/blog/2007/08/closures-in-python.html Closures in Python</ref>

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.<ref>http://dl.acm.org/citation.cfm?id=1026483 Guimar˜aes, Jos´e de Oliveira. "Closures for Statically-Typed Object-Oriented Languages"</ref>
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. <ref> http://en.wikipedia.org/wiki/Static_scope Static Scope</ref>
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.<ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29 Closure like implementation in C++</ref>

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. <ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java Closures like implementation in Java</ref>

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. <ref>http://en.wikipedia.org/wiki/Static_scope Static Scope</ref> Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

$arr = Array.new
def funcGen(val)
0.upto(val) do |i|
$arr[i] = Proc.new{print i}
end
end
funcGen(4)
$arr.each do |val|
val.call
end

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. <ref>http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx C# Anonymous methods</ref>

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.<ref>http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope Scheme </ref>

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
<ref>http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work Closures in scheme </ref>

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-26T00:42:07Z

Sgurram:

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between [http://en.wikipedia.org/wiki/Type_system#Static_typing statically] and [http://en.wikipedia.org/wiki/Type_system#Dynamic_typing dynamically] typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed.: [http://en.wikipedia.org/wiki/C_(programming_language) C],C++,Java,JADE,Pascal etc<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref> 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''<ref>http://www.artima.com/intv/closures2.html Blocks and Closures</ref>

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
<ref>http://www.codethinked.com/c-closures-explained C# Closures</ref>

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. <ref>http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby</ref>

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
<ref>http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS</ref>

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.<ref>http://ynniv.com/blog/2007/08/closures-in-python.html Closures in Python</ref>

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.<ref>http://dl.acm.org/citation.cfm?id=1026483 Guimar˜aes, Jos´e de Oliveira. "Closures for Statically-Typed Object-Oriented Languages"</ref>
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. <ref> http://en.wikipedia.org/wiki/Static_scope Static Scope</ref>
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.<ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29 Closure like implementation in C++</ref>

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. <ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java Closures like implementation in Java</ref>

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. <ref>http://en.wikipedia.org/wiki/Static_scope Static Scope</ref> Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

$arr = Array.new
def funcGen(val)
0.upto(val) do |i|
$arr[i] = Proc.new{print i}
end
end
funcGen(4)
$arr.each do |val|
val.call
end

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. <ref>http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx C# Anonymous methods</ref>

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.<ref>http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope Scheme </ref>

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
<ref>http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work Closures in scheme </ref>

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-26T00:08:57Z

Sgurram: /* Statically vs Dynamically typed */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed.: C,C++,Java,JADE,Pascal etc<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref> 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''<ref>http://www.artima.com/intv/closures2.html Blocks and Closures</ref>

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
<ref>http://www.codethinked.com/c-closures-explained C# Closures</ref>

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. <ref>http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby</ref>

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
<ref>http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS</ref>

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.<ref>http://ynniv.com/blog/2007/08/closures-in-python.html Closures in Python</ref>

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.<ref>http://dl.acm.org/citation.cfm?id=1026483 Guimar˜aes, Jos´e de Oliveira. "Closures for Statically-Typed Object-Oriented Languages"</ref>
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. <ref> http://en.wikipedia.org/wiki/Static_scope Static Scope</ref>
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.<ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29 Closure like implementation in C++</ref>

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. <ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java Closures like implementation in Java</ref>

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. <ref>http://en.wikipedia.org/wiki/Static_scope Static Scope</ref> Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

$arr = Array.new
def funcGen(val)
0.upto(val) do |i|
$arr[i] = Proc.new{print i}
end
end
funcGen(4)
$arr.each do |val|
val.call
end

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. <ref>http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx C# Anonymous methods</ref>

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.<ref>http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope Scheme </ref>

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
<ref>http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work Closures in scheme </ref>

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T21:30:55Z

Sgurram: /* Closures and Static Scoping */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''<ref>http://www.artima.com/intv/closures2.html Blocks and Closures</ref>

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
<ref>http://www.codethinked.com/c-closures-explained C# Closures</ref>

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. <ref>http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby</ref>

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
<ref>http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS</ref>

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.<ref>http://ynniv.com/blog/2007/08/closures-in-python.html Closures in Python</ref>

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.<ref>http://dl.acm.org/citation.cfm?id=1026483 Guimar˜aes, Jos´e de Oliveira. "Closures for Statically-Typed Object-Oriented Languages"</ref>
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. <ref> http://en.wikipedia.org/wiki/Static_scope Static Scope</ref>
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.<ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29 Closure like implementation in C++</ref>

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. <ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java Closures like implementation in Java</ref>

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. <ref>http://en.wikipedia.org/wiki/Static_scope Static Scope</ref> Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. <ref>http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx C# Anonymous methods</ref>

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.<ref>http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope Scheme </ref>

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
<ref>http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work Closures in scheme </ref>

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T21:29:15Z

Sgurram: /* Closures and Static Scoping */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''<ref>http://www.artima.com/intv/closures2.html Blocks and Closures</ref>

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
<ref>http://www.codethinked.com/c-closures-explained C# Closures</ref>

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. <ref>http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby</ref>

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
<ref>http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS</ref>

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.<ref>http://ynniv.com/blog/2007/08/closures-in-python.html Closures in Python</ref>

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.<ref>http://dl.acm.org/citation.cfm?id=1026483 Guimar˜aes, Jos´e de Oliveira. "Closures for Statically-Typed Object-Oriented Languages"</ref>
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. <ref> http://en.wikipedia.org/wiki/Static_scope Static Scope</ref>
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.<ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29 Closure like implementation in C++</ref>

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. <ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java Closures like implementation in Java</ref>

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. <ref>http://en.wikipedia.org/wiki/Static_scope Static Scope</ref> Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
<ref>http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx C# Anonymous methods</ref>

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T21:28:38Z

Sgurram: /* Closures and Static Scoping */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''<ref>http://www.artima.com/intv/closures2.html Blocks and Closures</ref>

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
<ref>http://www.codethinked.com/c-closures-explained C# Closures</ref>

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. <ref>http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby</ref>

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
<ref>http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS</ref>

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.<ref>http://ynniv.com/blog/2007/08/closures-in-python.html Closures in Python</ref>

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.<ref>http://dl.acm.org/citation.cfm?id=1026483 Guimar˜aes, Jos´e de Oliveira. "Closures for Statically-Typed Object-Oriented Languages"</ref>
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. <ref> http://en.wikipedia.org/wiki/Static_scope Static Scope</ref>
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.<ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29 Closure like implementation in C++</ref>

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. <ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java Closures like implementation in Java</ref>

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. <ref>http://en.wikipedia.org/wiki/Static_scope Static Scope</ref> Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T21:27:55Z

Sgurram: /* Example in Java */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''<ref>http://www.artima.com/intv/closures2.html Blocks and Closures</ref>

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
<ref>http://www.codethinked.com/c-closures-explained C# Closures</ref>

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. <ref>http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby</ref>

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
<ref>http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS</ref>

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.<ref>http://ynniv.com/blog/2007/08/closures-in-python.html Closures in Python</ref>

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.<ref>http://dl.acm.org/citation.cfm?id=1026483 Guimar˜aes, Jos´e de Oliveira. "Closures for Statically-Typed Object-Oriented Languages"</ref>
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. <ref> http://en.wikipedia.org/wiki/Static_scope Static Scope</ref>
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.<ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29 Closure like implementation in C++</ref>

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. <ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java Closures like implementation in Java</ref>

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T21:27:24Z

Sgurram: /* Example in C++ */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''<ref>http://www.artima.com/intv/closures2.html Blocks and Closures</ref>

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
<ref>http://www.codethinked.com/c-closures-explained C# Closures</ref>

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. <ref>http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby</ref>

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
<ref>http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS</ref>

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.<ref>http://ynniv.com/blog/2007/08/closures-in-python.html Closures in Python</ref>

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.<ref>http://dl.acm.org/citation.cfm?id=1026483 Guimar˜aes, Jos´e de Oliveira. "Closures for Statically-Typed Object-Oriented Languages"</ref>
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. <ref> http://en.wikipedia.org/wiki/Static_scope Static Scope</ref>
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.<ref>http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29 Closure like implementation in C++</ref>

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java]

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T21:26:49Z

Sgurram: /* Statically typed languages, difficulty */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''<ref>http://www.artima.com/intv/closures2.html Blocks and Closures</ref>

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
<ref>http://www.codethinked.com/c-closures-explained C# Closures</ref>

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. <ref>http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby</ref>

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
<ref>http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS</ref>

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.<ref>http://ynniv.com/blog/2007/08/closures-in-python.html Closures in Python</ref>

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.<ref>http://dl.acm.org/citation.cfm?id=1026483 Guimar˜aes, Jos´e de Oliveira. "Closures for Statically-Typed Object-Oriented Languages"</ref>
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. <ref> http://en.wikipedia.org/wiki/Static_scope Static Scope</ref>
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.[http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29]

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java]

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T21:25:40Z

Sgurram: /* Example in Python */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''<ref>http://www.artima.com/intv/closures2.html Blocks and Closures</ref>

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
<ref>http://www.codethinked.com/c-closures-explained C# Closures</ref>

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. <ref>http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby</ref>

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
<ref>http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS</ref>

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.<ref>http://ynniv.com/blog/2007/08/closures-in-python.html Closures in Python</ref>

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.[http://dl.acm.org/citation.cfm?id=1026483]
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. [http://en.wikipedia.org/wiki/Static_scope]
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.[http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29]

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java]

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T21:24:59Z

Sgurram: /* Example in JS */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''<ref>http://www.artima.com/intv/closures2.html Blocks and Closures</ref>

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
<ref>http://www.codethinked.com/c-closures-explained C# Closures</ref>

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. <ref>http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby</ref>

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
<ref>http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS</ref>

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.[http://ynniv.com/blog/2007/08/closures-in-python.html]

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.[http://dl.acm.org/citation.cfm?id=1026483]
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. [http://en.wikipedia.org/wiki/Static_scope]
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.[http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29]

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java]

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T21:22:18Z

Sgurram: /* Example in Ruby */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''<ref>http://www.artima.com/intv/closures2.html Blocks and Closures</ref>

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
<ref>http://www.codethinked.com/c-closures-explained C# Closures</ref>

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. <ref>http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby</ref>

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
[http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.[http://ynniv.com/blog/2007/08/closures-in-python.html]

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.[http://dl.acm.org/citation.cfm?id=1026483]
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. [http://en.wikipedia.org/wiki/Static_scope]
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.[http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29]

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java]

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T21:19:20Z

Sgurram: /* What exactly is Closure */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''<ref>http://www.artima.com/intv/closures2.html Blocks and Closures</ref>

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
<ref>http://www.codethinked.com/c-closures-explained C# Closures</ref>

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
[http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.[http://ynniv.com/blog/2007/08/closures-in-python.html]

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.[http://dl.acm.org/citation.cfm?id=1026483]
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. [http://en.wikipedia.org/wiki/Static_scope]
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.[http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29]

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java]

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T21:18:40Z

Sgurram: /* Closures */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''<ref>http://www.artima.com/intv/closures2.html Blocks and Closures</ref>

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
<ref> http://www.artima.com/intv/closures2.html Blocks and Closures </ref>

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
[http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.[http://ynniv.com/blog/2007/08/closures-in-python.html]

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.[http://dl.acm.org/citation.cfm?id=1026483]
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. [http://en.wikipedia.org/wiki/Static_scope]
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.[http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29]

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java]

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T21:16:30Z

Sgurram: /* Closures */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''[http://www.artima.com/intv/closures2.html]

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
<ref> http://www.artima.com/intv/closures2.html Blocks and Closures </ref>

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
[http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.[http://ynniv.com/blog/2007/08/closures-in-python.html]

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.[http://dl.acm.org/citation.cfm?id=1026483]
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. [http://en.wikipedia.org/wiki/Static_scope]
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.[http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29]

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java]

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T21:11:42Z

Sgurram: /* Statically vs Dynamically typed */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref> http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing </ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''[http://www.artima.com/intv/closures2.html]

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
[http://www.codethinked.com/c-closures-explained]

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
[http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.[http://ynniv.com/blog/2007/08/closures-in-python.html]

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.[http://dl.acm.org/citation.cfm?id=1026483]
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. [http://en.wikipedia.org/wiki/Static_scope]
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.[http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29]

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java]

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T21:10:21Z

Sgurram: /* References */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref name="Static Typing"/>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''[http://www.artima.com/intv/closures2.html]

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
[http://www.codethinked.com/c-closures-explained]

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
[http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.[http://ynniv.com/blog/2007/08/closures-in-python.html]

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.[http://dl.acm.org/citation.cfm?id=1026483]
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. [http://en.wikipedia.org/wiki/Static_scope]
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.[http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29]

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java]

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==
<references />

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T21:10:10Z

Sgurram: /* Statically vs Dynamically typed */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref name="Static Typing"/>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''[http://www.artima.com/intv/closures2.html]

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
[http://www.codethinked.com/c-closures-explained]

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
[http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.[http://ynniv.com/blog/2007/08/closures-in-python.html]

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.[http://dl.acm.org/citation.cfm?id=1026483]
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. [http://en.wikipedia.org/wiki/Static_scope]
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.[http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29]

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java]

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T21:04:14Z

Sgurram: /* References */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref name="Static Typing"/>{{cite web
url = http://en.wikipedia.org/wiki/Type_system#Static_typing
}}</ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''[http://www.artima.com/intv/closures2.html]

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
[http://www.codethinked.com/c-closures-explained]

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
[http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.[http://ynniv.com/blog/2007/08/closures-in-python.html]

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.[http://dl.acm.org/citation.cfm?id=1026483]
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. [http://en.wikipedia.org/wiki/Static_scope]
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.[http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29]

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java]

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T21:03:12Z

Sgurram: /* Statically vs Dynamically typed */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref name="Static Typing"/>{{cite web
url = http://en.wikipedia.org/wiki/Type_system#Static_typing
}}</ref>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''[http://www.artima.com/intv/closures2.html]

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
[http://www.codethinked.com/c-closures-explained]

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
[http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.[http://ynniv.com/blog/2007/08/closures-in-python.html]

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.[http://dl.acm.org/citation.cfm?id=1026483]
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. [http://en.wikipedia.org/wiki/Static_scope]
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.[http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29]

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java]

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==
[1] http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing 
[2] http://www.artima.com/intv/closures2.html Blocks and Closures 
[3] http://www.codethinked.com/c-closures-explained C# Closures 
[4] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby 
[5] http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS 
[6] http://ynniv.com/blog/2007/08/closures-in-python.html Closures in Python 
[7] http://dl.acm.org/citation.cfm?id=1026483 Guimar˜aes, Jos´e de Oliveira. "Closures for Statically-Typed Object-Oriented Languages" 
[8] http://en.wikipedia.org/wiki/Static_scope Static Scope 
[9] http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29 Closure like implementation in C++ 
[10] http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java Closures like implementation in Java 
[11] http://en.wikipedia.org/wiki/Static_scope Static Scope 
[12] http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx C# Anonymous methods 
[13] http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope Scheme 
[14] http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work Closures in scheme

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T20:57:50Z

Sgurram: /* Statically vs Dynamically typed */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.<ref name="Static Typing"/>

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''[http://www.artima.com/intv/closures2.html]

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
[http://www.codethinked.com/c-closures-explained]

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
[http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.[http://ynniv.com/blog/2007/08/closures-in-python.html]

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.[http://dl.acm.org/citation.cfm?id=1026483]
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. [http://en.wikipedia.org/wiki/Static_scope]
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.[http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29]

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java]

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==
[1] http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing 
[2] http://www.artima.com/intv/closures2.html Blocks and Closures 
[3] http://www.codethinked.com/c-closures-explained C# Closures 
[4] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby 
[5] http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS 
[6] http://ynniv.com/blog/2007/08/closures-in-python.html Closures in Python 
[7] http://dl.acm.org/citation.cfm?id=1026483 Guimar˜aes, Jos´e de Oliveira. "Closures for Statically-Typed Object-Oriented Languages" 
[8] http://en.wikipedia.org/wiki/Static_scope Static Scope 
[9] http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29 Closure like implementation in C++ 
[10] http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java Closures like implementation in Java 
[11] http://en.wikipedia.org/wiki/Static_scope Static Scope 
[12] http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx C# Anonymous methods 
[13] http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope Scheme 
[14] http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work Closures in scheme

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T20:54:14Z

Sgurram: /* statically typed languages, difficulty */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.[http://en.wikipedia.org/wiki/Type_system#Static_typing]

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''[http://www.artima.com/intv/closures2.html]

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
[http://www.codethinked.com/c-closures-explained]

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
[http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.[http://ynniv.com/blog/2007/08/closures-in-python.html]

=== Statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.[http://dl.acm.org/citation.cfm?id=1026483]
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. [http://en.wikipedia.org/wiki/Static_scope]
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.[http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29]

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java]

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==
[1] http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing 
[2] http://www.artima.com/intv/closures2.html Blocks and Closures 
[3] http://www.codethinked.com/c-closures-explained C# Closures 
[4] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby 
[5] http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS 
[6] http://ynniv.com/blog/2007/08/closures-in-python.html Closures in Python 
[7] http://dl.acm.org/citation.cfm?id=1026483 Guimar˜aes, Jos´e de Oliveira. "Closures for Statically-Typed Object-Oriented Languages" 
[8] http://en.wikipedia.org/wiki/Static_scope Static Scope 
[9] http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29 Closure like implementation in C++ 
[10] http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java Closures like implementation in Java 
[11] http://en.wikipedia.org/wiki/Static_scope Static Scope 
[12] http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx C# Anonymous methods 
[13] http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope Scheme 
[14] http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work Closures in scheme

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T20:53:58Z

Sgurram: /* what exactly is Closure */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.[http://en.wikipedia.org/wiki/Type_system#Static_typing]

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''[http://www.artima.com/intv/closures2.html]

=== What exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
[http://www.codethinked.com/c-closures-explained]

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
[http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.[http://ynniv.com/blog/2007/08/closures-in-python.html]

=== statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.[http://dl.acm.org/citation.cfm?id=1026483]
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. [http://en.wikipedia.org/wiki/Static_scope]
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.[http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29]

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java]

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==
[1] http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing 
[2] http://www.artima.com/intv/closures2.html Blocks and Closures 
[3] http://www.codethinked.com/c-closures-explained C# Closures 
[4] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby 
[5] http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS 
[6] http://ynniv.com/blog/2007/08/closures-in-python.html Closures in Python 
[7] http://dl.acm.org/citation.cfm?id=1026483 Guimar˜aes, Jos´e de Oliveira. "Closures for Statically-Typed Object-Oriented Languages" 
[8] http://en.wikipedia.org/wiki/Static_scope Static Scope 
[9] http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29 Closure like implementation in C++ 
[10] http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java Closures like implementation in Java 
[11] http://en.wikipedia.org/wiki/Static_scope Static Scope 
[12] http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx C# Anonymous methods 
[13] http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope Scheme 
[14] http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work Closures in scheme

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T20:53:39Z

Sgurram: /* statically vs dynamically typed */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== Statically vs Dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of Statically typed : C,C++,Java,JADE,Pascal etc 
Examples of Dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.[http://en.wikipedia.org/wiki/Type_system#Static_typing]

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''[http://www.artima.com/intv/closures2.html]

=== what exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
[http://www.codethinked.com/c-closures-explained]

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
[http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.[http://ynniv.com/blog/2007/08/closures-in-python.html]

=== statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.[http://dl.acm.org/citation.cfm?id=1026483]
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. [http://en.wikipedia.org/wiki/Static_scope]
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.[http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29]

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java]

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==
[1] http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing 
[2] http://www.artima.com/intv/closures2.html Blocks and Closures 
[3] http://www.codethinked.com/c-closures-explained C# Closures 
[4] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby 
[5] http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS 
[6] http://ynniv.com/blog/2007/08/closures-in-python.html Closures in Python 
[7] http://dl.acm.org/citation.cfm?id=1026483 Guimar˜aes, Jos´e de Oliveira. "Closures for Statically-Typed Object-Oriented Languages" 
[8] http://en.wikipedia.org/wiki/Static_scope Static Scope 
[9] http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29 Closure like implementation in C++ 
[10] http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java Closures like implementation in Java 
[11] http://en.wikipedia.org/wiki/Static_scope Static Scope 
[12] http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx C# Anonymous methods 
[13] http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope Scheme 
[14] http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work Closures in scheme

CSC/ECE 517 Fall 2011/ch1 1d ss

2011-09-24T20:33:49Z

Sgurram: /* References */

''Closures in statically typed languages. Most languages that implement closures are dynamically typed. It is a challenge to implement closures in a statically typed language. Explain why, and cover attempts to mix the two. Consider also closures and static scoping, as in Scheme.''

== Introduction ==
We start off with a brief difference between statically and dynamically typed languages.We try to explain what a closure is, its advantages, how it can be implemented in various typed languages, why is it easier or difficult in some languages.Finally we conclude with static scoping.

=== statically vs dynamically typed ===
One simple way to differentiate between the two is: In statically typed languages,type checking is done at the compile time where as in dynamically typed languages, type checking is done at run-time.

Examples of statically typed : C,C++,Java,JADE,Pascal etc 
Examples of dynamically typed : PHP,Prolog,Python,Ruby,Small talk etc.[http://en.wikipedia.org/wiki/Type_system#Static_typing]

== Closures ==
In the words of Matsumoto, the creator of Ruby language: ''A closure object has code to run, the executable, and state around the code, the scope. So you capture the environment, namely the local variables, in the closure. As a result, you can refer to the local variables inside a closure. Even after the function has returned, and its local scope has been destroyed, the local variables remain in existence as part of the closure object. When no one refers to the closure anymore, it's garbage collected, and the local variables go away. ''[http://www.artima.com/intv/closures2.html]

=== what exactly is Closure ===
*A closure is a first-class block of code that has access to the environment in which it was defined.
**A first class function is one that can be passed around just like any other object.
**The function can access ‘free variables’, ie, variables that are not an argument to, or a local variable of that function. For example, if we have a function that returns a lambda function:

public Func<int,int> GetFunc()
{
int y = 4;
Func<int, int> myfunc = x => { return x+y; };
return myfunc;
}

y is neither an input parameter nor a local variable declared within myfunc. The free variable is bound in the lexical environment. This means that even when GetFunc goes out of scope, myfunc will still have access to it.
[http://www.codethinked.com/c-closures-explained]

=== Advantages of Closures ===
*It allows access to contextual information that wouldn’t be available inside a standard method of a class.
*It can be passed around as an object and retain that context, even if the variables are outside their original scope. 
*There is no need to pass around internal variables for every call.
*Offers a more concise and clean method of programming operations.

== Implementation of Closures ==

=== In dynamically typed languages ===
We give the implementations of Closures in some of the dynamic languages.
==== Example in Ruby ====
Ruby implements closures with the support of procs and lambdas.These constructs are similar with subtle differences.Here is an example of closure in Ruby.
class SomeClass
def initialize(value1)
@value1 = value1
end

def value_printer(value2)
lambda {puts "Value1: #{@value1}, Value2: #{value2}"}
end
end

def caller(some_closure)
some_closure.call
end

some_class = SomeClass.new(5)
printer = some_class.value_printer("some value")

caller(printer)

when executed, we get the following ,value1 =5 and value2 = some value
 
As you can see, the value_printer function creates a closure, using the lambda construct, and then returns it. We then assign our closure to a variable and pass that variable to another function, which then calls our closure. This satisfies the first property of a closure – we can pass it around. Notice also that when we called our closure, we printed out "5" and "some value". Even though both the @value1 and value2 variables were both well and truly out of scope in the rest of the program when we finally called the closure; inside the closure they were still in scope as it retained the state of all the variables that were in scope when it was defined. [http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/]

==== Example in JS ====
we can access private members via closures in JS.As private members can only be accessed from inside your function,this comes handy.The same holds true for private methods(or functions,since we are in JavaScript here).This can be easily done with closure.

var namespace = {};
(namespace.someClass = function() {
var _privateProperty = "some value";
function _privateMethod() {
//perform some stuff
}
return {
publicProperty: "some value",
publicMethod: function publicMethod() {
//perform some stuff
}
}
}());

By looking closer at what exactly is happening, you'll notice that namespace.someClass is equal to an auto invoked function that returns an object literal.when executed an object that is assigned to namespace.someClass._privateProperty and _privateMethod() get closured and are now available to someClass,but since their containing function is no longer in scope, they are not available to anyone else.
[http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/]

==== Example in Python ====
def makeInc(x):
def inc(y):
# x is "closed" in the definition of inc
return y + x
return inc

inc5 = makeInc(5)
inc10 = makeInc(10)

inc5 (5) # returns 10
inc10(5) # returns 15

Closures in python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a different binding of x. The example shows the closure of x being used to eliminate either a global or a constant, depending on the nature of x.[http://ynniv.com/blog/2007/08/closures-in-python.html]

=== statically typed languages, difficulty ===
We can explain this via an example.
Method setBlock is defined as

|n|
...
b := [ n >= 0 ifTrue: ^1 ifFalse: ^0 ].

where b is an instance variable.After calling setBlock, a method of the same class may be called and may execute the above block - b value.

Inside the block there will be a return (^1 or ^0) from a method call of setBlock that no longer exists — a runtime error.
 
It seems impossible to add true closures to statically typed languages because of the above described run time errors.Although these errors may be considered as "type errors", they make the language unsafe which is against the norm of statically typed languages.[http://dl.acm.org/citation.cfm?id=1026483]
*Closures will need access to the lexical scope, ie, the scope in which the routine was generated as mentioned above. This is a problem for statically typed languages as they keep track of local variables in the stack. Once those variables go out of scope and the routine tries to access them, it will throw an exception. This problem must be overcome as closures must have access to that environment, even when it's out of scope. [http://en.wikipedia.org/wiki/Static_scope]
*In addition, since they must be first class functions, ie, the ability to use them as a normal data type, the statically typed language must have a specific type defined for functions. In the case of Java and C#, the garbage collector must keep those objects around, as well as their associated lexical environments, until there are no remaining references to that object.

=== In statically typed languages ===
Some of the object oriented languages simulate some of the features of closures.
==== Example in C++ ====
For example:
*C++ defines function objects by overloading operator().They may be created at run time and may implicitly capture the state but they don't have the access to local variables as closures do.

*Two proposals to introduce C++ language support for closures (both proposals call them lambda functions) are being considered by the C++ Standards Committee.The main difference between these proposals is that one stores a copy of all the local variables in a closure by default, and another stores references to original variables. Both provide functionality to override the default behavior. If some form of these proposals is accepted, one would be able to write

void foo(string myname) {
typedef vector<string> names;
int y;
names n;
// ...
names::iterator i = std::find_if(n.begin(), n.end(), [&](const string& s) {
return s != myname && s.size() > y;
});
// 'i' is now either 'n.end()' or points to the first string in 'n'
// which is not equal to 'myname' and whose length is greater than 'y'
}

At least two C++ compilers, Visual C++ 2010 and GCC 4.5, already support this notation.[http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29]

==== Example in Java ====

JAVA allows functionality similar to closures via anonymous classes; an anonymous class may refer to names in lexically enclosing classes, or read-only variables (marked as final) in the lexically enclosing method.

class CalculationWindow extends JFrame {
private volatile int result;
...
public void calculateInSeparateThread(final URI uri) {
// The expression "new Runnable() { ... }" is an anonymous class.
new Thread(
new Runnable() {
void run() {
// It can read final local variables:
calculate(uri);
// It can access private fields of the enclosing class:
result = result + 10;
}
}
).start();
}
}

Some features of full closures can be emulated by using a final reference to a mutable container, for example, a single-element array. The inner class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container. [http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java]

== Closures and Static Scoping ==
Static scoping (also known as Lexical scoping) is a property of the runtime text and is independent of the runtime call stack. [http://en.wikipedia.org/wiki/Static_scope] Implementing closures in a statically scoped language can be very challenging.
*It requires each function to maintain the variables in the scope in which the closure was declared, even after they have dropped out of scope.
*When using static scoping languages that implement closures there is some question as to whether to have access to the actual mutable variable or to a copy of the value at the time it was declared. In other words, do we close over variables or values? This is something that developers must ascertain when using closures.
For example in Ruby if we have this code:

<code>
$arr = Array.new
def funcGen(val)
0.upto(val)
do |i|
$arr[i] = Proc.new {
print i
}
end
end
funcGen(4)
$arr.each
do |val|
val.call
end
</code>

We will have an output similiar to this:
01234

It uses a copy of the value, not the variable.

However, in C# if we have code does something similiar:

<code>
delegate void Func();
class Program
{
static Func[] funcArr = new Func[4];
static void Main(string[] args)
{
fillFunc(funcArr.Length);
for (int i = 0; i < funcArr.Length; i++)
{
funcArr[i]();
}
}
static void fillFunc(int count)
{
for (int i = 0; i < count; i++)
{
funcArr[i] = delegate() { Console.Write("{0}", i); };
}
}
}
</code>

We will have this output.
4444

The last value set in the environment is used. This means that in this case, it closes over the variable, not the value, whereas Ruby closes over the value. [http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx]

===Scheme's way of handling===

Scheme is one of the two main dialects of programming language LISP.It's design policy is to provide small core and powerful tools for language extension.Compactness and Elegance are some of the few features what made Scheme popular in various communities of researchers.

Scheme is lexically scoped like most of the modern programming languages.all possible variable bindings in a program unit can be analyzed by reading the text of the program unit without consideration of the contexts in which it may be called.

The key insights on how to introduce lexical scoping into a Lisp dialect were popularized in Sussman and Steele's 1975 Lambda Paper, "Scheme: An Interpreter for Extended Lambda Calculus" where they adopted the concept of the lexical closure.[http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope]

An example in Scheme
(define (makem)
(define x 34)
(list (lambda () (set! x (+ x 1)) x)
(lambda () (set! x (+ x 1)) x))
)
(define f (car (makem)))
(define f2 (car (cdr (makem))))
> (f)
35
> (f2)
35
> (f)
36
> (f)
37
>
[http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work]

== References ==
[1] http://en.wikipedia.org/wiki/Type_system#Static_typing Static Typing 
[2] http://www.artima.com/intv/closures2.html Blocks and Closures 
[3] http://www.codethinked.com/c-closures-explained C# Closures 
[4] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures in Ruby 
[5] http://tinyhippos.com/2010/07/05/closure-in-javascript-with-examples/ Closures in JS 
[6] http://ynniv.com/blog/2007/08/closures-in-python.html Closures in Python 
[7] http://dl.acm.org/citation.cfm?id=1026483 Guimar˜aes, Jos´e de Oliveira. "Closures for Statically-Typed Object-Oriented Languages" 
[8] http://en.wikipedia.org/wiki/Static_scope Static Scope 
[9] http://en.wikipedia.org/wiki/Closure_%28computer_science%29#C.2B.2B_.28operator_overloading.29 Closure like implementation in C++ 
[10] http://en.wikipedia.org/wiki/Closure_%28computer_science%29#Java Closures like implementation in Java 
[11] http://en.wikipedia.org/wiki/Static_scope Static Scope 
[12] http://blogs.msdn.com/b/abhinaba/archive/2005/10/18/482180.aspx C# Anonymous methods 
[13] http://en.wikipedia.org/wiki/Scheme_(programming_language)#Lexical_scope Scheme 
[14] http://stackoverflow.com/questions/5608325/how-do-closures-in-scheme-work Closures in scheme