Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2009/wiki3 7 f1

2009-11-17T15:31:05Z

Ssatish: /* Separating Design from Engineering */

This wikipedia article focuses on how [http://en.wikipedia.org/wiki/Agile_software_development Agile] software development methodology can complement other design methodologies. Section 1 highlights the advantage of agile over traditional models, like the [http://en.wikipedia.org/wiki/Waterfall_model waterfall model]. Section 2 highlights why it might not be possible to introduce all of the agile practices at the same time. Section 3 takes up a few design methodologies and focuses on how agile complements them.

== Agile vs Traditional Methodologies ==

The agile manifesto focuses on

*''' Individuals and interactions''' over processes and tools

*'''Working software''' over comprehensive documentation

* '''Customer collaboration''' over contract negotiation

* '''Responding to change''' over following a plan

That is, while there is value in the items on the right, agile values the items on the left more. The items on the right are what the traditional design methodologies emphasise on.

===Advantages of the agile method===

* Once a stage is completed in the Waterfall method, there is no going back, since most software designed and implemented under the waterfall method is hard to change according to time and user needs. The problem can only be fixed by going back and designing an entirely new system, a very costly and inefficient method. Whereas, Agile methods adapt to change, as at the end of each stage, the logical programme, designed to cope and adapt to new ideas from the outset, allows changes to be made easily. With Agile, changes can be made if necessary without getting the entire programme rewritten. This approach not only reduces overheads, it also helps in the upgrading of programmes.

* Another Agile method advantage is one has a launchable product at the end of each tested stage. This ensures bugs are caught and eliminated in the development cycle, and the product is double tested again after the first bug elimination. This is not possible for the Waterfall method, since the product is tested only at the very end, which means any bugs found results in the entire programme having to be re-written.

* Agile’s modular nature means employing better suited object-oriented designs and programmes, which means one always has a working model for timely release even when it does not always entirely match customer specifications. Whereas, there is only one main release in the waterfall method and any problems or delays mean highly dissatisfied customers.

* Agile methods allow for specification changes as per end-user’s requirements, spelling customer satisfaction. As already mentioned, this is not possible when the waterfall method is employed, since any changes to be made means the project has to be started all over again.

* However, both methods do allow for a sort of departmentalization e.g. in waterfall departmentalization is done at each stage. As for Agile, each coding module can be delegated to separate groups. This allows for several parts of the project to be done at the same time, though departmentalization is more effectively used in Agile methodologies.

==Challenges in Applying Agile Methodologies==

* [3] researches about the challenges in applying agile and concludes by introducing a set of new and modified development practices, which will help in developing a large agile project. One of the aspects common to many agile development methodologies is that the entire team (business analysts, developers, and testers) collaborate very heavily. With a large project, this type of collaboration is difficult at best. Teams tend to break up into subteams for better communication. The downside to subteams is the possibility that the subteams build stove-piped sub-systems if communication is insufficient among the teams. Problems of consistency and duplication may go undiscovered. Of course, there are other practices that help alleviate these problems such as rotating team members among the subteams, having an overall design document, etc. The different subteams may result in a non-homogeneous and inconsistent architecture.

* Many of the solutions agile methods promote, draw on a limited set of techniques for managing organizations and understanding customers. [7] focuses on incorporating customer-centered techniques such as [http://en.wikipedia.org/wiki/Contextual_design Contextual Design] to provide additional solutions to the real problems recognized by agile methods. These solutions work in combination with agile methods’ strengths resulting in a process that incorporates the customer voice, provides room for UI and user interaction design, and can address significantly large projects.

== Study of a few Design methodologies and How Agile Complements Them==

Separating Design from Engineering: Much of the distinctiveness (and much of the value) of agile methods comes from the
clear separation of responsibilities they bring to the development process. Developers
write code and design the implementation of systems—that is what they are good at.
They are not good at understanding how people work, creating effective and intuitive
user interfaces, or making an interface usable.

The great strength of agile methods is that they focus the engineers on doing what
engineers do best. The weakness of agile methods is that they give little guidance in
figuring out what to tell the engineers to do.

Core Team: Possible agile solutions would be to start with a core team which builds out a simple business case in a test-driven manner. This first phase will build out enough of most of the architecture. With a small team, a full agile methodology works without modification. When a significant portion of the architecture is built, it is time to divide the project by growing the development team and splitting up into smaller subteams to grow the project into a fully functional software system.

Role of an architect: While there is no traditional architect role in most agile development methodologies, in large teams, it is often beneficial to reintroduce a modified version of this role. The architect is a member of the team with significant design and development talent and experience and he has to understand the ‘whole’ application code-base. The architect is hands-on and pairs with others on the team frequently and will be a participant in many agile modeling design sessions on the whiteboard. This helps keep away redundancies.

Continuous Integration: While each sub-team will have their own build running, agile methodology suggests having a 'brain' team that will have to create a master build that builds all sub-teams code and/or deploy their binary files. The master build will run frequently by pulling down the last successful builds for sub projects, compile and deploy the whole project and run the tests. In case of failure the brain team has to identify the problem and resolve it or take it to the responsible sub team to resolve it.

Refactoring: In large projects Refactoring sometimes becomes very expensive process and may take a month to be done. Some design ahead may be done to save expensive major refactoring later. For the conquer team when it’s still early on the project, to avoid large complicated refactoring some extra time should be spent for designing for future known requirements. Having the overall picture of use cases will make it easier to predict future requirements and create a design that will handle them. This design ahead is allowed only during the conquer phase of the project and will only apply to core systems, frameworks and similar subsystems of the system which may be more expensive to be re-factored.

Tests: To reduce the cost of refactoring, the team may depend on functional tests more than unit tests. Functional tests test the functionality of the system and in general do not depend on the system design. Unit tests should still be created for test driven development and for critical pieces of the system that may cause the system to break. Tests that are created after the development and tests created for reported bugs should be functional tests. Having less unit tests will lead to more time spent in debugging issues and functional tests cannot pin point problems but having a better design through constant refactoring will reduce the development time much more than the extra time being spent in debugging issues. Functional test should be documented in each test to describe the test scenario, expected results and differences between test scenarios.

These are some of the recommended practices that will help mediate some of the problems in applying agile design methodologies to projects. There are also some difficulties with applying these practices such as with the master build, with communication between teams, with extreme designing to get useless frameworks, and care should be taken to avoid them.

== References==

# [http://virtual.vtt.fi/virtual/xp2006/ XP 2006 Website]
# [http://www.agile200x.org/ Agile Development Conference]
# Experience Paper: Applying Agile to Large Projects: New Agile Software Development Practices for Large Projects- Ahmed Elshamy and Amr Elssamadisy
# Research Paper: Comparative Analysis of Job Satisfaction in Agile and Non-Agile Software Development Teams- Grigori Melnik, Frank Maurer
# Rolling the DICE for agile software projects- Bartlomiej Ziolkowski, Geoffrey Drake
# Incorporating Learning and Expected Cost of Change in Prioritizing Features on Agile Projects- Scott Harris, Mike Cohn
# An Agile User-Centered Method: Rapid Contextual Design- Hugh Beyer, Karen Holtzblatt, Lisa Baker

CSC/ECE 517 Fall 2009/wiki2 17 f1

2009-10-08T23:21:53Z

Ssatish:

'''Service Oriented Architecture provides another view of providing functionality based upon services offered in terms of protocols and a specific API. To provide services, platforms rely upon principles and the power that can be expressed through reflection and meta programming. Research and report how these critical concepts relate to and support SOA.'''

== Service Oriented Architectures==
[http://en.wikipedia.org/wiki/Service_Oriented_Architectures Service Oriented Architecture] is a paradigm for organizing and utilizing distributed capabilities that may be under the control of different ownership domains. It provides a uniform means to offer, discover, interact with and use capabilities to produce desired effects consistent with measurable preconditions and expectations.

This makes it easier for software integration of different modules developed by different people. Rather than defining an [http://en.wikipedia.org/wiki/API API], SOA defines the interface in terms of protocols and functionality such that modules following these protocols can easily be integrated together. The main characteristics of SOA are:

* '''Based on open standards''' - The governing principles are free for all to use and not protected by intellectual property.
* '''Interoperable''' - Diverse systems should be able to work together (inter-operate)
* '''Autonomous''' - Services have control over the logic they encapsulate.
* '''Reusable''' - Logic is divided into services with the intention of promoting reuse.
* '''Reliable''' - It should not have many flaws
* '''Discoverable''' - Services are designed to be outwardly descriptive so that they can be found and assessed via available discovery mechanisms
* '''Loosely-Coupled''' - Loose coupling occurs when the dependent class contains a pointer only to an interface, which can then be implemented by one or many concrete classes.
* '''Stateless''' - Should exhibit the same behaviour and yield the same result whether called once, or 100 times
* '''Composable''' - Collections of services can be coordinated and assembled to form composite services.
* '''Manageable''' - It should be easy to maintain it
* '''Secure''' - It should not be easily hackable

=== Core Components of SOA===
* '''SOAP''': Simple Object Access Protocol - As a layman's example of how SOAP procedures can be used, a SOAP message could be sent to a web service enabled web site (for example, a house price database) with the parameters needed for a search. The site would then return an [http://en.wikipedia.org/wiki/XML XML]-formatted document with the resulting data (prices, location, features, etc). Because the data is returned in a standardized machine-parseable format, it could then be integrated directly into a third-party site.
* '''WSDL''': Web Services Description Language - Its an XML-based language that provides a model for describing Web Services.
* '''UDDI''': Universal Discovery, Definition and Integration - Its an XML-based database for companies world-wide to list themselves on the internet
* '''BPEL''': Business Process Execution Language - Its a language for specifying interaction with web services.
* '''ESB''': [http://en.wikipedia.org/wiki/Enterprise_service_bus Enterprise Service Bus]
* '''WS-*''': Web Services Standards - a collection of protocols and standards used for exchanging data between applications

===Benefits of SOA ===
* Improve long-term value of software assets
* Improve quality through modularity and testability
* Reduce development time with composition and reusability
* Leverage heterogeneous development environments
* Avoid vendor and platform lock-in
* Integrate with [http://en.wikipedia.org/wiki/Enterprise_resource_planning ERPs] and Enterprise infrastructure software

===Use cases for SOA with Ruby===
Ruby can be a productive way to:
* Build web applications over web services
* Write web services tests with minimal code
* Write custom web services monitoring and management
* Integrate ERPs, [http://en.wikipedia.org/wiki/Commercial_off-the-shelf COTS] and custom applications
* Write SOA glue-code, e.g. custom transformation
* Perform programmatic web services orchestration
* Develop basic web services

==Reflection in Ruby==

One of the many advantages of dynamic languages such as Ruby is the ability to introspect—to examine aspects of the program from within the program itself. This is called reflection. At runtime, we can discover the following things about our ruby program -
* what objects it contains,
* the class hierarchy,
* the attributes and methods of objects, and
* information on methods.

Ruby provide a module called "ObjectSpace" that lets you to use reflection and see all the above mentioned information. So if you say,
<pre>
ObjectSpace.each_object { |x| puts x }
</pre>
will print all living, nonimmediate objects in Ruby process.

<pre>
ObjectSpace.each_object(Class) { |x| puts x}
</pre>
will print all classes in Ruby process.

The following code iterates over all the classes, compares their name. If name matches then create object and execute whichever function you like.
<pre>
class ClassFromString
@@counter = 0
def initialize
@@counter += 1
end
def getCounterValue
puts @@counter
end
end

def createClassFromString(classname)
ObjectSpace.each_object(Class) do |x|
if x.name == classname
object = x.new
object.getCounterValue
object = x.new
object.getCounterValue
end
end
end
createClassFromString("ClassFromString")
</pre>

Once you get the object you can use any method of that object. For e.g. you can use superclass method to get the name of the parent class and so on and can build complete hierarchy dynamically.
You can get the information about methods of a given class using methods like private_methods(), protected_methods() which are defined in Object class which is base class for each object.

'''Distributed Ruby''' and '''Marshalling''' are two reflection-based technologies that let us send objects around the world and through time, which enables use of Service Oriented Architectures.

===Marshalling===

Java features the ability to serialize objects, letting you store them somewhere and reconstitute them when needed.
To "serialize" an object means to convert its state into a byte stream in such a way that the byte stream can be converted back into a copy of the object. You can use this facility, for instance, to save a tree of objects that represent some portion of application state—a document, a CAD drawing, a piece of music, and so on.
Ruby calls this kind of serialization marshaling (think of railroad marshaling yards where individual cars are assembled in sequence into a complete train, which is then dispatched somewhere). Saving an object and some or all of its components is done using the method ''Marshal.dump''. Typically, you will dump an entire object tree starting with some given object. Later, you can reconstitute the object using ''Marshal.load''.

Example -

We have a class Chord that holds a collection of musical notes. We’d like to save away a particularly wonderful chord so we can e-mail it to friends. They can then load it into their copy of Ruby and savor it too. Let’s start with the classes for Note and Chord.

<pre>

Note = Struct.new(:value)
class Note
def to_s
value.to_s
end
end

class Chord
def initialize(arr)
@arr = arr
end
def play
@arr.join('')
end
end

</pre>

Now we’ll create our masterpiece and use Marshal.dump to save a serialized version of it to disk.

<pre>

c = Chord.new( [ Note.new("G"),
Note.new("Bb"),
Note.new("Db"),
Note.new("E") ] )
File.open("posterity", "w+") do |f|
Marshal.dump(c, f)
end

</pre>

Finally, it can be read by our friends.

<pre>
File.open("posterity") do |f|
chord = Marshal.load(f)
end
chord.play ! "GBbDbE"
</pre>

=== Distributed Ruby ===
Distributed Ruby or DRb allows Ruby programs to communicate with each other on the same machine or over a network. DRb uses remote method invocation (RMI) to pass commands and data between processes. Since we can serialize an object or a set of objects into a form suitable for out-ofprocess storage, we can use this capability for the transmission of objects from one process to another. Using drb, a Ruby process may act as a server, as a client, or as both. A drb server acts as a source of objects, while a client is a user of those objects. To the client, it appears
that the objects are local, but in reality the code is still being executed remotely. This can be found in the SOAP implementation of RUBY libraries.

CSC/ECE 517 Fall 2009/wiki2 17 f1

2009-10-08T23:05:26Z

Ssatish:

'''Service Oriented Architecture provides another view of providing functionality based upon services offered in terms of protocols and a specific API. To provide services, platforms rely upon principles and the power that can be expressed through reflection and meta programming. Research and report how these critical concepts relate to and support SOA.'''

== Service Oriented Architectures==
[http://en.wikipedia.org/wiki/Service_Oriented_Architectures Service Oriented Architecture] is a paradigm for organizing and utilizing distributed capabilities that may be under the control of different ownership domains. It provides a uniform means to offer, discover, interact with and use capabilities to produce desired effects consistent with measurable preconditions and expectations.

This makes it easier for software integration of different modules developed by different people. Rather than defining an [http://en.wikipedia.org/wiki/API API], SOA defines the interface in terms of protocols and functionality such that modules following these protocols can easily be integrated together. The main characteristics of SOA are:

* '''Based on open standards''' - The governing principles are free for all to use and not protected by intellectual property.
* '''Interoperable''' - Diverse systems should be able to work together (inter-operate)
* '''Autonomous''' - Services have control over the logic they encapsulate.
* '''Reusable''' - Logic is divided into services with the intention of promoting reuse.
* '''Reliable''' - It should not have many flaws
* '''Discoverable''' - Services are designed to be outwardly descriptive so that they can be found and assessed via available discovery mechanisms
* '''Loosely-Coupled''' - Loose coupling occurs when the dependent class contains a pointer only to an interface, which can then be implemented by one or many concrete classes.
* '''Stateless''' - Should exhibit the same behaviour and yield the same result whether called once, or 100 times
* '''Composable''' - Collections of services can be coordinated and assembled to form composite services.
* '''Manageable''' - It should be easy to maintain it
* '''Secure''' - It should not be easily hackable

=== Core Components of SOA===
* '''SOAP''': Simple Object Access Protocol - As a layman's example of how SOAP procedures can be used, a SOAP message could be sent to a web service enabled web site (for example, a house price database) with the parameters needed for a search. The site would then return an [http://en.wikipedia.org/wiki/XML XML]-formatted document with the resulting data (prices, location, features, etc). Because the data is returned in a standardized machine-parseable format, it could then be integrated directly into a third-party site.
* '''WSDL''': Web Services Description Language - Its an XML-based language that provides a model for describing Web Services.
* '''UDDI''': Universal Discovery, Definition and Integration - Its an XML-based database for companies world-wide to list themselves on the internet
* '''BPEL''': Business Process Execution Language - Its a language for specifying interaction with web services.
* '''ESB''': [http://en.wikipedia.org/wiki/Enterprise_service_bus Enterprise Service Bus]
* '''WS-*''': Web Services Standards - a collection of protocols and standards used for exchanging data between applications

===Benefits of SOA ===
* Improve long-term value of software assets
* Improve quality through modularity and testability
* Reduce development time with composition and reusability
* Leverage heterogeneous development environments
* Avoid vendor and platform lock-in
* Integrate with [http://en.wikipedia.org/wiki/Enterprise_resource_planning ERPs] and Enterprise infrastructure software

===Use cases for SOA with Ruby===
Ruby can be a productive way to:
* Build web applications over web services
* Write web services tests with minimal code
* Write custom web services monitoring and management
* Integrate ERPs, [http://en.wikipedia.org/wiki/Commercial_off-the-shelf COTS] and custom applications
* Write SOA glue-code, e.g. custom transformation
* Perform programmatic web services orchestration
* Develop basic web services

==Reflection in Ruby==

One of the many advantages of dynamic languages such as Ruby is the ability to introspect—to examine aspects of the program from within the program itself. This is called reflection. At runtime, we can discover the following things about our ruby program -
* what objects it contains,
* the class hierarchy,
* the attributes and methods of objects, and
* information on methods.

Ruby provide a module called "ObjectSpace" that lets you to use reflection and see all the above mentioned information. So if you say,
<pre>
ObjectSpace.each_object { |x| puts x }
</pre>
will print all living, nonimmediate objects in Ruby process.

<pre>
ObjectSpace.each_object(Class) { |x| puts x}
</pre>
will print all classes in Ruby process.

The following code iterates over all the classes, compares their name. If name matches then create object and execute whichever function you like.
<pre>
class ClassFromString
@@counter = 0
def initialize
@@counter += 1
end
def getCounterValue
puts @@counter
end
end

def createClassFromString(classname)
ObjectSpace.each_object(Class) do |x|
if x.name == classname
object = x.new
object.getCounterValue
object = x.new
object.getCounterValue
end
end
end
createClassFromString("ClassFromString")
</pre>

Once you get the object you can use any method of that object. For e.g. you can use superclass method to get the name of the parent class and so on and can build complete hierarchy dynamically.
You can get the information about methods of a given class using methods like private_methods(), protected_methods() which are defined in Object class which is base class for each object.

'''Distributed Ruby''' and '''Marshalling''' are two reflection-based technologies that let us send objects around the world and through time, which enables use of Service Oriented Architectures.

===Marshalling===

Java features the ability to serialize objects, letting you store them somewhere and reconstitute them when needed. You can use this facility, for instance, to save a tree of objects that represent some portion of application state—a document, a CAD drawing, a piece of music, and so on.
Ruby calls this kind of serialization marshaling (think of railroad marshaling yards where individual cars are assembled in sequence into a complete train, which is then dispatched somewhere). Saving an object and some or all of its components is done using the method ''Marshal.dump''. Typically, you will dump an entire object tree starting with some given object. Later, you can reconstitute the object using ''Marshal.load''.

Example -

We have a class Chord that holds a collection of musical notes. We’d like to save away a particularly wonderful chord so we can e-mail it to friends. They can then load it into their copy of Ruby and savor it too. Let’s start with the classes for Note and Chord.

<pre>

Note = Struct.new(:value)
class Note
def to_s
value.to_s
end
end

class Chord
def initialize(arr)
@arr = arr
end
def play
@arr.join('')
end
end

</pre>

Now we’ll create our masterpiece and use Marshal.dump to save a serialized version of it to disk.

<pre>

c = Chord.new( [ Note.new("G"),
Note.new("Bb"),
Note.new("Db"),
Note.new("E") ] )
File.open("posterity", "w+") do |f|
Marshal.dump(c, f)
end

</pre>

Finally, it can be read by our friends.

<pre>
File.open("posterity") do |f|
chord = Marshal.load(f)
end
chord.play ! "GBbDbE"
</pre>

CSC/ECE 517 Fall 2009/wiki2 17 f1

2009-10-08T22:41:13Z

Ssatish:

CSC/ECE 517 Fall 2009/wiki2 17 f1

2009-10-08T22:16:51Z

Ssatish: /* Reflection in Ruby */

CSC/ECE 517 Fall 2009/wiki2 17 f1

2009-10-08T22:10:49Z

Ssatish: /* Reflection in Ruby */

CSC/ECE 517 Fall 2009/wiki2 17 f1

2009-10-08T21:57:21Z

Ssatish:

CSC/ECE 517 Fall 2009/wiki2 17 f1

2009-10-08T21:38:43Z

Ssatish:

CSC/ECE 517 Fall 2009/wiki2 17 f1

2009-10-08T21:35:56Z

Ssatish:

CSC/ECE 517 Fall 2009/wiki2 17 f1

2009-10-08T21:35:18Z

Ssatish:

'''SOA provides another view of providing functionality based upon services offered in terms of protocols and a specific API. To provide services, platforms rely upon principles and the power that can be expressed through reflection and meta programming. Research and report how these critical concepts relate to and support SOA.'''

== Service Oriented Architectures==
[http://en.wikipedia.org/wiki/Service_Oriented_Architectures Service Oriented Architecture] is a paradigm for organizing and utilizing distributed capabilities that may be under the control of different ownership domains. It provides a uniform means to offer, discover, interact with and use capabilities to produce desired effects consistent with measurable preconditions and expectations.

This makes it easier for software integration of different modules developed by different people. Rather than defining an [http://en.wikipedia.org/wiki/API API], SOA defines the interface in terms of protocols and functionality such that modules following these protocols can easily be integrated together. The main characteristics of SOA are:

* '''Based on open standards''' - The governing principles are free for all to use and not protected by intellectual property.
* '''Interoperable''' - Diverse systems should be able to work together (inter-operate)
* '''Autonomous''' - Services have control over the logic they encapsulate.
* '''Reusable''' - Logic is divided into services with the intention of promoting reuse.
* '''Reliable''' - It should not have many flaws
* '''Discoverable''' - Services are designed to be outwardly descriptive so that they can be found and assessed via available discovery mechanisms
* '''Loosely-Coupled''' - Loose coupling occurs when the dependent class contains a pointer only to an interface, which can then be implemented by one or many concrete classes.
* '''Stateless''' - Should exhibit the same behaviour and yield the same result whether called once, or 100 times
* '''Composable''' - Collections of services can be coordinated and assembled to form composite services.
* '''Manageable''' - It should be easy to maintain it
* '''Secure''' - It should not be easily hackable

== Core Components of SOA==
* '''SOAP''': Simple Object Access Protocol - As a layman's example of how SOAP procedures can be used, a SOAP message could be sent to a web service enabled web site (for example, a house price database) with the parameters needed for a search. The site would then return an [http://en.wikipedia.org/wiki/XML XML]-formatted document with the resulting data (prices, location, features, etc). Because the data is returned in a standardized machine-parseable format, it could then be integrated directly into a third-party site.
* '''WSDL''': Web Services Description Language - Its an XML-based language that provides a model for describing Web Services.
* '''UDDI''': Universal Discovery, Definition and Integration - Its an XML-based database for companies world-wide to list themselves on the internet
* '''BPEL''': Business Process Execution Language - Its a language for specifying interaction with web services.
* '''ESB''': [http://en.wikipedia.org/wiki/Enterprise_service_bus Enterprise Service Bus]
* '''WS-*''': Web Services Standards - a collection of protocols and standards used for exchanging data between applications

==Benefits of SOA ==
* Improve long-term value of software assets
* Improve quality through modularity and testability
* Reduce development time with composition and reusability
* Leverage heterogeneous development environments
* Avoid vendor and platform lock-in
* Integrate with [http://en.wikipedia.org/wiki/Enterprise_resource_planning ERPs] and Enterprise infrastructure software

CSC/ECE 517 Fall 2009/wiki2 17 f1

2009-10-08T20:56:56Z

Ssatish: /* Core Components of SOA */

CSC/ECE 517 Fall 2009/wiki2 17 f1

2009-10-08T20:55:00Z

Ssatish: /* Core Components of SOA */

'''SOA provides another view of providing functionality based upon services offered in terms of protocols and a specific API. To provide services, platforms rely upon principles and the power that can be expressed through reflection and meta programming. Research and report how these critical concepts relate to and support SOA.'''

== Service Oriented Architectures==
[http://en.wikipedia.org/wiki/Service_Oriented_Architectures Service Oriented Architecture] is a paradigm for organizing and utilizing distributed capabilities that may be under the control of different ownership domains. It provides a uniform means to offer, discover, interact with and use capabilities to produce desired effects consistent with measurable preconditions and expectations.

This makes it easier for software integration of different modules developed by different people. Rather than defining an [http://en.wikipedia.org/wiki/API API], SOA defines the interface in terms of protocols and functionality such that modules following these protocols can easily be integrated together. The main characteristics of SOA are:

* '''Based on open standards''' - The governing principles are free for all to use and not protected by intellectual property.
* '''Interoperable''' - Diverse systems should be able to work together (inter-operate)
* '''Autonomous''' - Services have control over the logic they encapsulate.
* '''Reusable''' - Logic is divided into services with the intention of promoting reuse.
* '''Reliable''' - It should not have many flaws
* '''Discoverable''' - Services are designed to be outwardly descriptive so that they can be found and assessed via available discovery mechanisms
* '''Loosely-Coupled''' - Loose coupling occurs when the dependent class contains a pointer only to an interface, which can then be implemented by one or many concrete classes.
* '''Stateless''' - Should exhibit the same behaviour and yield the same result whether called once, or 100 times
* '''Composable''' - Collections of services can be coordinated and assembled to form composite services.
* '''Manageable''' - It should be easy to maintain it
* '''Secure''' - It should not be easily hackable

== Core Components of SOA==
* '''SOAP''': Simple Object Access Protocol - As a layman's example of how SOAP procedures can be used, a SOAP message could be sent to a web service enabled web site (for example, a house price database) with the parameters needed for a search. The site would then return an XML-formatted document with the resulting data (prices, location, features, etc). Because the data is returned in a standardized machine-parseable format, it could then be integrated directly into a third-party site.
* '''WSDL''': Web Services Description Language - Its an XML-based language that provides a model for describing Web Services.
* '''UDDI''': Universal Discovery, Definition and Integration - Its an XML-based database for companies world-wide to list themselves on the internet
* '''BPEL''': Business Process Execution Language - Its a language for specifying interaction with web services.
* '''ESB''': [http://en.wikipedia.org/wiki/Enterprise_service_bus Enterprise Service Bus]
* '''WS-*''': Web Services Standards - a collection of protocols and standards used for exchanging data between applications

CSC/ECE 517 Fall 2009/wiki2 17 f1

2009-10-08T20:42:59Z

Ssatish:

CSC/ECE 517 Fall 2009/wiki2 17 f1

2009-10-08T20:41:28Z

Ssatish: /* Service Oriented Architectures */

'''Using Reflection and Meta programming to support Service Oriented Architectures'''

== Service Oriented Architectures==
[http://en.wikipedia.org/wiki/Service_Oriented_Architectures Service Oriented Architecture] is a paradigm for organizing and utilizing distributed capabilities that may be under the control of different ownership domains. It provides a uniform means to offer, discover, interact with and use capabilities to produce desired effects consistent with measurable preconditions and expectations.

This makes it easier for software integration of different modules developed by different people. Rather than defining an [http://en.wikipedia.org/wiki/API API], SOA defines the interface in terms of protocols and functionality such that modules following these protocols can easily be integrated together. The main characteristics of SOA are:

* '''Based on open standards''' - The governing principles are free for all to use and not protected by intellectual property.
* '''Interoperable''' - Diverse systems should be able to work together (inter-operate)
* '''Autonomous''' - Services have control over the logic they encapsulate.
* '''Reusable''' - Logic is divided into services with the intention of promoting reuse.
* '''Reliable''' - It should not have many flaws
* '''Discoverable''' - Services are designed to be outwardly descriptive so that they can be found and assessed via available discovery mechanisms
* '''Loosely-Coupled''' - Loose coupling occurs when the dependent class contains a pointer only to an interface, which can then be implemented by one or many concrete classes.
* '''Stateless''' - Should exhibit the same behaviour and yield the same result whether called once, or 100 times
* '''Composable''' - Collections of services can be coordinated and assembled to form composite services.
* '''Manageable''' - It should be easy to maintain it
* '''Secure''' - It should not be easily hackable

== Core Components of SOA==
* '''SOAP''': Simple Object Access Protocol -
* '''WSDL''': Web Services Description Language
* '''UDDI''': Universal Discovery, Definition and Integration
* '''BPEL''': Business Process Execution Language
* '''ESB''': Enterprise Service Bus
* '''WS-*''': Web Services Standards

CSC/ECE 517 Fall 2009/wiki2 17 f1

2009-10-08T20:36:21Z

Ssatish: /* Service Oriented Architectures */

CSC/ECE 517 Fall 2009/wiki2 17 f1

2009-10-08T20:34:48Z

Ssatish: /* Service Oriented Architectures */

'''Using Reflection and Meta programming to support Service Oriented Architectures'''

== Service Oriented Architectures==
[http://en.wikipedia.org/wiki/Service_Oriented_Architectures Service Oriented Architecture] is a paradigm for organizing and utilizing distributed capabilities that may be under the control of different ownership domains. It provides a uniform means to offer, discover, interact with and use capabilities to produce desired effects consistent with measurable preconditions and expectations.

This makes it easier for software integration of different modules developed by different people. Rather than defining an [http://en.wikipedia.org/wiki/API API], SOA defines the interface in terms of protocols and functionality such that modules following these protocols can easily be integrated together. The main characteristics of SOA are:

* Based on open standards - The governing principles are free for all to use and not protected by intellectual property.
* Interoperable - Diverse systems should be able to work together (inter-operate)
* Autonomous - Services have control over the logic they encapsulate.
* Reusable - Logic is divided into services with the intention of promoting reuse.
* Reliable - It should not have many flaws
* Discoverable - Services are designed to be outwardly descriptive so that they can be found and assessed via available discovery mechanisms
* Loosely-Coupled - Loose coupling occurs when the dependent class contains a pointer only to an interface, which can then be implemented by one or many concrete classes.
* Stateless - Should exhibit the same behaviour and yield the same result whether called once, or 100 times
* Composable - Collections of services can be coordinated and assembled to form composite services.
* Manageable - It should be easy to maintain it
* Secure - It should not be easily hackable

CSC/ECE 517 Fall 2009/wiki2 17 f1

2009-10-08T20:11:48Z

Ssatish: /* Service Oriented Architectures */

CSC/ECE 517 Fall 2009/wiki2 17 f1

2009-10-08T20:02:05Z

Ssatish: /* Service Oriented Architectures */

'''Using Reflection and Meta programming to support Service Oriented Architectures'''

== Service Oriented Architectures==
[http://en.wikipedia.org/wiki/Service_Oriented_Architectures Service Oriented Architecture] is an approach to building software as a set of autonomous, reusable and [http://en.wikipedia.org/wiki/Interoperability interoperable] units of functionality using open standards. Rather than defining an [http://en.wikipedia.org/wiki/API API], SOA defines the interface in terms of protocols and functionality.

CSC/ECE 517 Fall 2009/wiki2 17 f1

2009-10-08T20:00:42Z

Ssatish:

'''Using Reflection and Meta programming to support Service Oriented Architectures'''

== Service Oriented Architectures==
[http://en.wikipedia.org/wiki/Service_Oriented_Architectures Service Oriented Architecture] is an approach to building software as a set of autonomous, reusable and [http://en.wikipedia.org/wiki/Interoperability interoperable] units of functionality using open standards. Rather than defining an API, SOA defines the interface in terms of protocols and functionality.

CSC/ECE 517 Fall 2009/wiki1a 11 f1,

2009-09-12T20:49:59Z

Ssatish: /* Ruby continuations vs Python Generators */

Ruby and Python are both scripting languages whose popularity has sky rocketed in recent years. Both languages are
[http://en.wikipedia.org/wiki/High_level_language High-Level], [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) Garbage-collected], and [http://en.wikipedia.org/wiki/Dynamically_typed#Dynamic_typing Dynamically-typed]. Both provide an interactive shell, standard libraries, and persistence support. So, what are the differences?

[[Image:svg2raster.png|frame|alt=Puzzle globe logo|Ruby Logo]]
[[Image:python.png|frame|alt=Puzzle globe logo|Python Logo]]

Points of comparison:
* Language Features: Ruby vs Python
* Programming environments
* Features exclusive to each of Ruby and Python
* Advantages of Ruby/Python over statically typed languages
* Project environments suited to each

==Language Features: Ruby vs Python==

===Access Protection ===

Ruby supports private, protected and public types of access (like java)to the elements of a class. By default all methods are public except the initialize method and all instance variables are private. One of the differences of Ruby compared to Python is that Ruby keeps all of its instance variables completely private to the class and only exposes them through accessor methods (attr_writer, attr_reader, etc).

Python's property descriptors are similar, but come with a trade-off in the development process. If one begins in Python by using a publicly exposed instance variable and later changes the implementation to use a private instance variable exposed through a property descriptor, code internal to the class may need to be adjusted to use the private variable rather than the public property. Ruby removes this design decision

===Functions and methods ===
In Ruby, the part which is different from Python is the fact that all operations are messages to objects. There are no separate functions and methods; all of them are methods.
<pre>
string = 'Hello world'
puts string.count('o'), string.length # prints 2, 11
</pre>
In Python, there are separate methods and functions as shown in the example below.
<pre>
string = 'Hello world'
print string.count('o'), len(string) # prints 2, 11 – why not string.len()?
</pre>

===Ruby has reference to class in class body ===

Ruby:
<pre>
class MyClass
initialize_magick()
end
</pre>
Rubys variant is cleaner, as the magic stuff is done in the class definition, so you see that it’s being done when you look at the class.

Python:
<pre>
class MyClass:
pass
initialize_magick(MyClass)
</pre>
But it’s really not a big deal, because calling the initialise method after the class or as a decorator is really not a major drawback.

=== Self Reference ===
In Python, one needs to write ''self'' as the first parameter of a method definition (alike Perl). Furthermore, Python doesn’t require the variable name to be self. In Ruby, ''self'' is automatically available in a similar fashion as in C++.

Additionally, the method call ''self.method'' can be shortened to ''method'', as ''self'' is the default receiver.

=== Ruby continuations vs Python Generators ===

Continuation is a "pointer" to the current position in your program, including calling stack and all variables. You can reuse that pointer to "go back in time" when needed. Continuations are useful when it comes to ''usecases''.
<pre>
def loop
cont=nil
for i in 1..4
puts i
callcc {|continuation| cont=continuation} if i==2
end
return cont
end
</pre> 

Python doesn't support full continuations or even coroutines; instead it supports "generator" functions which create a kind of limited coroutine.
A generator in python is implemented as a special syntax for creating an instance of an iterator object, which returns the values returned by the "function" definition you provide. Python generators are easy and clean.
The equivalent code for the above code segment, in python is

<pre>
from generator_tools import copy_generator

def _callg(generator, generator_copy=None):
for _ in generator: # run to the end
pass
if generator_copy is not None:
return lambda: _callg(copy_generator(generator_copy))

def loop(c):
c.next() # advance to yield's expression
return _callg(c, copy_generator(c))

if __name__ == '__main__':
def loop_gen():
i = 1
while i <= 4:
print i
if i == 2:
yield
i += 1

c = loop(loop_gen())
print("c:", c)
for _ in range(2):
print("c():", c())
</pre>

=== Indentation===

Python uses whitespace indentation, rather than curly braces or keywords, to delimit statement blocks (a feature also known as the off-side rule). An increase in indentation comes after certain statements; a decrease in indentation signifies the end of the current block.
On the other hand, ruby doesn't need any indentation although it can be optionally used for clarity.

=== Other Differences ===
{| class="wikitable" border="1"
|-
! Feature
! Ruby
! Python
|-
| Higher-Order Functions
| Implemented with procedure objects
| Implemented as lambda expressions
|-
| Arrays and hashes
| supports Arrays and associative arrays (Hash)
| has Lists and Tuples which are the same as arrays.

|-
| Memory management
| has a mark and sweep garbage collector
| has a reference counting garbage collector.

|-
| Parallel assignment
| claims to do Operating System independent threading.
| Threading available on many common platforms with some threading support

|-
| Package support
| Not available
| Available

|}

== Programming Environments ==

===Development Environments===
Both languages provide interactive shells (type "python" or "irb") and high-level persistence support. Multiple IDEs are available for Python, including GUI debuggers. A gdb-style debugger is available for each language. Python has a RefactoringBrowser, BicycleRepairMan. RubyLanguage now has a [http://www.kmc.gr.jp/proj/rrb/index-en.html RubyRefactoringBrowser]

Both languages are supported by Emacs modes. Python can be used as an elisp replacement - see Pymacs. The current Ruby implementation is closely tied to Unix, making Windows performance and ports to new platforms problematic. There is an EclipseIde for Ruby. RubyCocoa adds support for Ruby to ProjectBuilder/ExCode on MacOsx.

===Web Programming Environments ===
Both Ruby and Python have a large number of web programming environments/ application frameworks. They are exhaustively listed and compared [http://en.wikipedia.org/wiki/Comparison_of_web_application_frameworks#Python here]. For brevity, we compare ruby's [http://en.wikipedia.org/wiki/Ruby_on_rails Ruby on Rails] with python's [http://en.wikipedia.org/wiki/Django_(web_framework) Django]. The need was to compare two frameworks which were developed independent of each other and not based or influenced on the other. Hence the choice of django was made, as other web python frameworks like pylons and web2py are based on rails.

Django is a complete Python web application framework while rails is an agile web programming environment built in Ruby which greatly simplifies MVC framework development. Ruby OO programming topics in conjunction with various Rails recipes are considered a much lighter, simpler and faster development experience than other current enterprise frameworks provided today.

The table below compares them.

{| class="wikitable" border="1"
|-
! Feature
! Ruby on Rails
! Django
|-
| Language
| Ruby
| Python
|-
| Ajax
| Prototype, script.aculo.us
| Yes
|-
| MVC framework
| ActiveRecord, Action Pack
| Yes
|-
| MVC Push/Pull
| Push
| Push
|-
| i18n & l10n?
| Localization, Plug-in
| Yes
|-
| ORM
| ActiveRecord
| Django ORM
|-
| Testing framework(s)
| Unit Tests, Functional Tests and Integration Tests
| Yes
|-
| DB migration framework(s)
| Yes
| No (plugin exists, might be merged into trunk when more stable and feature complete)
|-
| Security Framework(s)
| Plug-in
| ACL-based
|-
| Template Framework(s)
| Yes
| Yes
|-
| Caching Framework(s)
| Yes
| Yes
|-
| Form Validation Framework(s)
| Yes
| Yes
|}

==Features exclusive to each of Ruby and Python==

===Python Advantages===
* Python has multiple inheritance
* Python has docstrings : Docstrings makes it possible to attach documentation directly to the classes and methods. That’s a nice documentation plus, and makes things like the Python interpreters ''help()'' function really useful.

===Ruby Advantages===
* Ruby blocks are much more powerful than Python lambdas and they are integrated pervasively into the language. They also allow interaction between the block and the container.
* Metaprogramming (modifying classes on the fly) is easier in Ruby than in Python. Interestingly, in the Ruby community this is considered a powerful feature and used frequently, whereas the Python community tends to think of it as a last resort.
* Ruby is very good at creating domain-specific mini-languages. This is a consequence of the easy metaprogramming and optional parentheses on function calls.

==Advantages of Ruby/Python over statically typed languages==

The term Dynamic language refers to high level programming language that allows the programmer to modify the code during run time. The modifications may include addition of new blocks of code or modifications to objects during execution or changing the type of objects. Statically typed languages such as Java or C# have type checking performed during compile-time as opposed to run-time and an objects type cannot be changed. Programmers should declare the types they intend a method or function to use and the compiler will not permit the programmer to ignore this type. Apart from being dynamically typed, there are many features provided by dynamic languages that aren’t to be found in Static languages. These include blocks and closures, metaprogramming, and unbounded polymorphism and support for multiple programming paradigms. These features lend certain advantages to a dynamic language which are listed below:

===Purely Object Oriented===
Ruby does not have primitives. everything, including integers are full fledged objects.
'''Ruby''':
<pre>
0.zero? This evaluates to a true
1.zero? This evaluates to a false
</pre>
===Typed features===
With Static typing in Java and C#, programmers should declare the types they want a method or function to use while with Ruby you don't declare types for variables or functions. In Ruby objects are strongly and dynamically typed.

'''Java''':
<pre>
int val1=5;
String value=String.valueOf(val1);
if(value.equals("5"))
</pre>

'''Python''':
<pre>
val1=5
value=str(val1)
if value == "5"
</pre>
===Verbosity===
Statically typed languages tend to be more verbose.

'''Java''':
<pre>
import java.io.*;
BufferedReader file1=new BufferedReader(new FileReader(Filename));
</pre>

'''Python''':
<pre>
file=open(Filename);
</pre>
===Relaxed syntax===
Ruby and Python are flexible with respect to syntax. For example,

'''Ruby''':
<pre>
cat = Cat.new
cat = Cat.new()
cat = Cat.new();
</pre>
===More compact code===
'''Java''':
<pre>
for (int i = 0; i < 100; i++)
{}
</pre>

'''Ruby''':
<pre>
100.times { |i| }
</pre>
===Default Arguments===
Ruby and Python allow you to define default values to method arguments while Java does not.

'''Ruby''':
<pre>
def calc_cube(x=2,y=3)
val=x**y
end
</pre>

===Checked Exceptions ===
Checked exceptions force every method to deal with (catching or throwing) all exceptions that its child calls or may call.

'''Java''':
If in the program, a method calls run as follows, A1() -> A2() -> A3() -> A4() and if A4() throws an Exception, and it is caught by A1(), then A2(), A3() must also throw the same Exception.

'''Python''':
Exceptions propagate upwards and A2() and A3() do not need to throw the Exception.
===Duck Typing===
Ruby doesn't care about an object's class, just whether it has a method of the name used in the method call. For this reason, the dynamic approach has earned the name duck typing.

'''Ruby''':
<pre>
class Duck
def sound
puts "Quack"
end
end

Class Frog
def sound
puts "Croak"
end
end

def noises(duck)
duck.sound
end

duckA=Duck.new
frogB=Frog.new

noises(frogB)
</pre>

'''Result''':
<pre>
"Croak"
</pre>

==Project Environments Suited to Each==

Python is useful for rapid prototyping, web scripting, XML processing, database applications, GUI applications, scientific computations. Python can be used for large and complex software systems. YouTube, for instance, runs mainly on Python, and it is preferred language at organizations including Google, NASA and Industrial Light and Magic. Specialized Python libraries and frameworks exist for scientific programming, data manipulation, Web services, XML interchange and many other things.

Ruby is useful for typical scripting language applications such as text processing and middleware programs. It is suitable for small, ad-hoc scripting tasks that previously may have been solved with Perl. Ruby has first-class regular expressions, which makes text processing scripts easy to write. Ruby is also suitable for larger software systems. It’s most successful application is in the Ruby on Rails web framework. Websites like Twitter and Hulu use the Ruby on Rails web development framework in production environments.
Ruby can also be used as a high-level API wrapper (or domain-specific language) around some C library. Other uses for Ruby is in test/behavior driven development and when you need to create an "internal" domain-specific language.

==References==

*[http://ruby.about.com/od/beginningruby/a/WhatIsRuby.htm What Is Ruby?]

*[http://blog.ianbicking.org/ruby-python-power.html Ruby, Python, "Power"]

*[http://python.about.com/od/gettingstarted/ss/whatispython_3.htm What is Python?]

*[http://johan.kiviniemi.name/blag/ruby-vs-python/ Ruby vs. Python Johan Kiviniemi's series of tubes]

*[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby (programming language)]

*[http://www.c2.com/cgi/wiki?PythonVsRuby Python Vs Ruby]

CSC/ECE 517 Fall 2009/wiki1a 11 f1,

2009-09-11T17:12:43Z

Ssatish: /* Language Features: Ruby vs Python */

Ruby and Python are both scripting languages whose popularity has sky rocketed in recent years. Both languages are
[http://en.wikipedia.org/wiki/High_level_language High-Level], [http://en.wikipedia.org/wiki/Garbage_collection_(computer_science) Garbage-collected], and [http://en.wikipedia.org/wiki/Dynamically_typed#Dynamic_typing Dynamically-typed]. Both provide an interactive shell, standard libraries, and persistence support. So, what are the differences?

[[Image:svg2raster.png|frame|alt=Puzzle globe logo|Ruby Logo]]
[[Image:python.png|frame|alt=Puzzle globe logo|Python Logo]]

Points of comparison:
* Language Features: Ruby vs Python
* Programming environments
* Features exclusive to each of Ruby and Python
* Advantages of Ruby/Python over statically typed languages
* Project environments suited to each

==Language Features: Ruby vs Python==

===Access Protection ===

Ruby supports private, protected and public types of access (like java)to the elements of a class. By default all methods are public except the initialize method and all instance variables are private. One of the differences of Ruby compared to Python is that Ruby keeps all of its instance variables completely private to the class and only exposes them through accessor methods (attr_writer, attr_reader, etc).

Python's property descriptors are similar, but come with a trade-off in the development process. If one begins in Python by using a publicly exposed instance variable and later changes the implementation to use a private instance variable exposed through a property descriptor, code internal to the class may need to be adjusted to use the private variable rather than the public property. Ruby removes this design decision

===Functions and methods ===
In Ruby, the part which is different from Python is the fact that all operations are messages to objects. There are no separate functions and methods; all of them are methods.
<pre>
string = 'Hello world'
puts string.count('o'), string.length # prints 2, 11
</pre>
In Python, there are separate methods and functions as shown in the example below.
<pre>
string = 'Hello world'
print string.count('o'), len(string) # prints 2, 11 – why not string.len()?
</pre>

===Ruby has reference to class in class body ===

Ruby:
<pre>
class MyClass
initialize_magick()
end
</pre>
Rubys variant is cleaner, as the magic stuff is done in the class definition, so you see that it’s being done when you look at the class.

Python:
<pre>
class MyClass:
pass
initialize_magick(MyClass)
</pre>
But it’s really not a big deal, because calling the initialise method after the class or as a decorator is really not a major drawback.

=== Self Reference ===
In Python, one needs to write ''self'' as the first parameter of a method definition (alike Perl). Furthermore, Python doesn’t require the variable name to be self. In Ruby, ''self'' is automatically available in a similar fashion as in C++.

Additionally, the method call ''self.method'' can be shortened to ''method'', as ''self'' is the default receiver.

=== Ruby continuations vs Python Generators ===

Continuation is a "pointer" to the current position in your program, including calling stack and all variables. You can reuse that pointer to "go back in time" when needed. Continuations are useful when it comes to ''usecases''.
<pre>
def loop
cont=nil
for i in 1..4
puts i
callcc {|continuation| cont=continuation} if i==2
end
return cont
end
</pre>

Python doesn't support full continuations or even coroutines; instead it supports "generator" functions which create a kind of limited coroutine.
A generator in python is implemented as a special syntax for creating an instance of an iterator object, which returns the values returned by the "function" definition you provide. Python generators are easy and clean.
The equivalent code for the above code segment, in python is

<pre>
from generator_tools import copy_generator

def _callg(generator, generator_copy=None):
for _ in generator: # run to the end
pass
if generator_copy is not None:
return lambda: _callg(copy_generator(generator_copy))

def loop(c):
c.next() # advance to yield's expression
return _callg(c, copy_generator(c))

if __name__ == '__main__':
def loop_gen():
i = 1
while i <= 4:
print i
if i == 2:
yield
i += 1

c = loop(loop_gen())
print("c:", c)
for _ in range(2):
print("c():", c())
</pre>

=== Indentation===

Python uses whitespace indentation, rather than curly braces or keywords, to delimit statement blocks (a feature also known as the off-side rule). An increase in indentation comes after certain statements; a decrease in indentation signifies the end of the current block.
On the other hand, ruby doesn't need any indentation although it can be optionally used for clarity.

=== Other Differences ===
{| class="wikitable" border="1"
|-
! Feature
! Ruby
! Python
|-
| Higher-Order Functions
| Implemented with procedure objects
| Implemented as lambda expressions
|-
| Arrays and hashes
| supports Arrays and associative arrays (Hash)
| has Lists and Tuples which are the same as arrays.

|-
| Memory management
| has a mark and sweep garbage collector
| has a reference counting garbage collector.

|-
| Parallel assignment
| claims to do Operating System independent threading.
| Threading available on many common platforms with some threading support

|-
| Package support
| Not available
| Available

|}

== Programming Environments ==

===Development Environments===
Both languages provide interactive shells (type "python" or "irb") and high-level persistence support. Multiple IDEs are available for Python, including GUI debuggers. A gdb-style debugger is available for each language. Python has a RefactoringBrowser, BicycleRepairMan. RubyLanguage now has a [http://www.kmc.gr.jp/proj/rrb/index-en.html RubyRefactoringBrowser]

Both languages are supported by Emacs modes. Python can be used as an elisp replacement - see Pymacs. The current Ruby implementation is closely tied to Unix, making Windows performance and ports to new platforms problematic. There is an EclipseIde for Ruby. RubyCocoa adds support for Ruby to ProjectBuilder/ExCode on MacOsx.

===Web Programming Environments ===
Both Ruby and Python have a large number of web programming environments/ application frameworks. They are exhaustively listed and compared [http://en.wikipedia.org/wiki/Comparison_of_web_application_frameworks#Python here]. For brevity, we compare ruby's [http://en.wikipedia.org/wiki/Ruby_on_rails Ruby on Rails] with python's [http://en.wikipedia.org/wiki/Django_(web_framework) Django]. The need was to compare two frameworks which were developed independent of each other and not based or influenced on the other. Hence the choice of django was made, as other web python frameworks like pylons and web2py are based on rails.

Django is a complete Python web application framework while rails is an agile web programming environment built in Ruby which greatly simplifies MVC framework development. Ruby OO programming topics in conjunction with various Rails recipes are considered a much lighter, simpler and faster development experience than other current enterprise frameworks provided today.

The table below compares them.

{| class="wikitable" border="1"
|-
! Feature
! Ruby on Rails
! Django
|-
| Language
| Ruby
| Python
|-
| Ajax
| Prototype, script.aculo.us
| Yes
|-
| MVC framework
| ActiveRecord, Action Pack
| Yes
|-
| MVC Push/Pull
| Push
| Push
|-
| i18n & l10n?
| Localization, Plug-in
| Yes
|-
| ORM
| ActiveRecord
| Django ORM
|-
| Testing framework(s)
| Unit Tests, Functional Tests and Integration Tests
| Yes
|-
| DB migration framework(s)
| Yes
| No (plugin exists, might be merged into trunk when more stable and feature complete)
|-
| Security Framework(s)
| Plug-in
| ACL-based
|-
| Template Framework(s)
| Yes
| Yes
|-
| Caching Framework(s)
| Yes
| Yes
|-
| Form Validation Framework(s)
| Yes
| Yes
|}

==Features exclusive to each of Ruby and Python==

===Python Advantages===
* Python has multiple inheritance
* Python has docstrings : Docstrings makes it possible to attach documentation directly to the classes and methods. That’s a nice documentation plus, and makes things like the Python interpreters ''help()'' function really useful.

===Ruby Advantages===
* Ruby blocks are much more powerful than Python lambdas and they are integrated pervasively into the language. They also allow interaction between the block and the container.
* Metaprogramming (modifying classes on the fly) is easier in Ruby than in Python. Interestingly, in the Ruby community this is considered a powerful feature and used frequently, whereas the Python community tends to think of it as a last resort.
* Ruby is very good at creating domain-specific mini-languages. This is a consequence of the easy metaprogramming and optional parentheses on function calls.

==Advantages of Ruby/Python over statically typed languages==

The term Dynamic language refers to high level programming language that allows the programmer to modify the code during run time. The modifications may include addition of new blocks of code or modifications to objects during execution or changing the type of objects. Statically typed languages such as Java or C# have type checking performed during compile-time as opposed to run-time and an objects type cannot be changed. Programmers should declare the types they intend a method or function to use and the compiler will not permit the programmer to ignore this type. Apart from being dynamically typed, there are many features provided by dynamic languages that aren’t to be found in Static languages. These include blocks and closures, metaprogramming, and unbounded polymorphism and support for multiple programming paradigms. These features lend certain advantages to a dynamic language which are listed below:

===Purely Object Oriented===
Ruby does not have primitives. everything, including integers are full fledged objects.
'''Ruby''':
<pre>
0.zero? This evaluates to a true
1.zero? This evaluates to a false
</pre>
===Typed features===
With Static typing in Java and C#, programmers should declare the types they want a method or function to use while with Ruby you don't declare types for variables or functions. In Ruby objects are strongly and dynamically typed.

'''Java''':
<pre>
int val1=5;
String value=String.valueOf(val1);
if(value.equals("5"))
</pre>

'''Python''':
<pre>
val1=5
value=str(val1)
if value == "5"
</pre>
===Verbosity===
Statically typed languages tend to be more verbose.

'''Java''':
<pre>
import java.io.*;
BufferedReader file1=new BufferedReader(new FileReader(Filename));
</pre>

'''Python''':
<pre>
file=open(Filename);
</pre>
===Relaxed syntax===
Ruby and Python are flexible with respect to syntax. For example,

'''Ruby''':
<pre>
cat = Cat.new
cat = Cat.new()
cat = Cat.new();
</pre>
===More compact code===
'''Java''':
<pre>
for (int i = 0; i < 100; i++)
{}
</pre>

'''Ruby''':
<pre>
100.times { |i| }
</pre>
===Default Arguments===
Ruby and Python allow you to define default values to method arguments while Java does not.

'''Ruby''':
<pre>
def calc_cube(x=2,y=3)
val=x**y
end
</pre>

===Checked Exceptions ===
Checked exceptions force every method to deal with (catching or throwing) all exceptions that its child calls or may call.

'''Java''':
If in the program, a method calls run as follows, A1() -> A2() -> A3() -> A4() and if A4() throws an Exception, and it is caught by A1(), then A2(), A3() must also throw the same Exception.

'''Python''':
Exceptions propagate upwards and A2() and A3() do not need to throw the Exception.
===Duck Typing===
Ruby doesn't care about an object's class, just whether it has a method of the name used in the method call. For this reason, the dynamic approach has earned the name duck typing.

'''Ruby''':
<pre>
class Duck
def sound
puts "Quack"
end
end

Class Frog
def sound
puts "Croak"
end
end

def noises(duck)
duck.sound
end

duckA=Duck.new
frogB=Frog.new

noises(frogB)
</pre>

'''Result''':
<pre>
"Croak"
</pre>

==Project Environments Suited to Each==

Python is useful for rapid prototyping, web scripting, XML processing, database applications, GUI applications, scientific computations. Python can be used for large and complex software systems. YouTube, for instance, runs mainly on Python, and it is preferred language at organizations including Google, NASA and Industrial Light and Magic. Specialized Python libraries and frameworks exist for scientific programming, data manipulation, Web services, XML interchange and many other things.

Ruby is useful for typical scripting language applications such as text processing and middleware programs. It is suitable for small, ad-hoc scripting tasks that previously may have been solved with Perl. Ruby has first-class regular expressions, which makes text processing scripts easy to write. Ruby is also suitable for larger software systems. It’s most successful application is in the Ruby on Rails web framework. Websites like Twitter and Hulu use the Ruby on Rails web development framework in production environments.
Ruby can also be used as a high-level API wrapper (or domain-specific language) around some C library. Other uses for Ruby is in test/behavior driven development and when you need to create an "internal" domain-specific language.

==References==

*[http://ruby.about.com/od/beginningruby/a/WhatIsRuby.htm What Is Ruby?]

*[http://blog.ianbicking.org/ruby-python-power.html Ruby, Python, "Power"]

*[http://python.about.com/od/gettingstarted/ss/whatispython_3.htm What is Python?]

*[http://johan.kiviniemi.name/blag/ruby-vs-python/ Ruby vs. Python Johan Kiviniemi's series of tubes]

*[http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby (programming language)]

*[http://www.c2.com/cgi/wiki?PythonVsRuby Python Vs Ruby]