Thursday 31 March 2011

Principles of SOA



Following are the principles of SOA:-

   1. Re-usability of services : Services are designed in such a way that they can be reused in the future.

   2. Stateless services : Services are designed so that their previous state  information is not stored. This feature supports the loosely coupled nature.

   3. Services share a formal contract : For services to interact they need to describe each services and the information to be exchanged.

   4. Composable services : Logic is represented at different levels, this feature facilitates reusable.

   5. Loose coupling : Services are not dependent on each other for operation.

   6. Services are autonomous : Services are not dependent on each other within the explicit boundary.

   7. Loosely coupled services : Services are designed in such a way that they interact with each other without the tight coupling and dependencies.

   8. Services abstract underlying logic : Service exposed via service contract is visible to outside world. Underlying logic other than what is specified in the contract is invisible.

SOA vs Client-Server architecture


Client-server has multiple intelligent clients which are connected to database on the server. In this environment the application logic will be placed in client software. Client work station is responsible for bulk of the processing, thus consuming most of the system resources and memory. Proprietary database connections were expensive and imposing latency. 

In contrast processing in SOA has an explicit functional boundary and related resource requirements. Most of the intelligence has been placed in the messages. There is no fixed processing ratio for SOAs.

Like client-server applications SOA also uses the visual basic and relational databases. However SOA requires that XML data representation architecture along with SOAP messaging has to be established. 

In client-server architecture the security is centralized at the server level. Operating system-level security can also be incorporated. That is the data is protected through a single point of authentication, but in SOA the security becomes significantly complex.

The major drawback of client-server architecture is the large maintenance cost. Updating the application code on each client caused high maintenance overhead.

Wednesday 30 March 2011

Comparision of SOA with Past Architectures

SOA Vs Client-Server architecture:-
   
Application Logic    
client-server places its majority of logic in client software which controls user experience and backend resources
whereas in SOA any software capable of exchanging SOAP messages are service requestors,it partitions logic into autonomus units to provide resuability across applications.

Application Processing
               Since logic resides in client side it must process bulk data,it must establish its own database connections which are expensive.client side executables are fully statefull and consumes a steady amount of PC memory whereas in SOA      processing is distributed and consists of explicit boundaries and resourse requirements to deploy services

Technology:-
  Client-Server uses technology like visual studio,C++ and database like mysql,sybase and RDBMS whereas SOA expands by adding web technologies like HTML,CSS,HTTP along with XML and SOAP messages.

Security:-
       Client-server is centralized at server level security.it can also control client executables and operating systems and data is protected via single point of authentication whereas in SOA security is provided by WS
security framework.

Principles Of SOA

The Principles of SOA are:

1.Reduced Cost :-
        SOA enables extensive reuse of existing funtionality  and infrastructure in multiple integrated projects.

2.Increased Flexibility :-
        SOA quickly adapt to applications inorder to meet changing business requirements and new         technologies  over time.

3.Integrates Incrementally :-
       This is the key benefit of SOA. It enables the users to provide knowledge based solutions which can be   integrated later in incremental fashion.

4.Loosely Coupled :-
           SOA proponents are loosely coupled. It depends on dimensionality like
Time:-when time is loosely coupled there is no need to be up and running at same time to communicate.
Location :-when location is loosely coupled participants can change location without having to re-program,reconfigure or restart communication among partners
Interface:- it provides a generic interface to communicate among partners.

5.Vendor Independent :-
           SOA does not depends upon particular vendor products whether it is commercial or free and open source.This implies interoperability and portability for applications.

6.Service Composability :-
service composability can be broken up in to two basic principles: service discoverability and service composition.Service discoverability is meant to help one avoid the accidental creation of services that are either redundant or implement logic that is redundant.





   






 

Wednesday 16 March 2011

cooking.dtd


<!ELEMENT recipes (recipe+)>
 <!ELEMENT recipe (recipe_head, recipe_body, recipe_footer?, document_info)>
 <!ELEMENT recipe_head (recipe_name, recipe_author?, meal_type)>
 <!ELEMENT recipe_name (#PCDATA)>
 <!ELEMENT recipe_author (#PCDATA)>
 <!ELEMENT meal_type (#PCDATA)>
 <!ELEMENT recipe_body (ingredients, directions)>
 <!ELEMENT ingredients (ingredient+)>
 <!ELEMENT ingredient (#PCDATA)>
 <!ELEMENT directions (direction)+ >
 <!ELEMENT direction (#PCDATA)>
 <!ELEMENT recipe_footer (serving?, preparation_time?, cooking_time?)>
 <!ELEMENT serving (#PCDATA)>
 <!ELEMENT preparation_time (#PCDATA)>
 <!ELEMENT cooking_time (#PCDATA)>
 <!ELEMENT document_info (document_author, date_updated, source)>
 <!ELEMENT document_author (#PCDATA)>
 <!ELEMENT date_updated (#PCDATA)>
 <!ELEMENT source (#PCDATA)>

cooking.xml


<?xml version="1.0"?>
<!DOCTYPE recipe SYSTEM "cooking.dtd">

<recipes>
   <recipe>
     <recipe_head>
<recipe_name> Spiced Sauce</recipe_name>
  <recipe_author>Pradeepn</recipe_author>
<meal_type>Fish and Shellfish</meal_type>
     </recipe_head>
  
     <recipe_body>
  <ingredients>
           <ingredient>1/2 teaspoon finely crushed cumin seeds</ingredient>
           <ingredient>1 teaspoon chilli powder</ingredient>
          <ingredient>salt and freshly ground black pepper</ingredient>
          <ingredient>2 tablespoons olive oil</ingredient>
          <ingredient>2 cloves garlic, crushed</ingredient>
          <ingredient>1.25 cm (1/2 in) fresh ginger root, finely chopped</ingredient>
         <ingredient>4 pieces salmon fillet, skinned</ingredient>
        <ingredient>125 ml (4 fl oz / 1/2 cup) double (heavy) cream</ingredient>
        <ingredient>250 ml (8 fl oz / 1 cup) thick plain yogurt</ingredient>
       <ingredient>large pinch of saffron threads, toasted and crushed</ingredient>
        <ingredient>seeds from 6 cardamom pods, toasted and finely crushed</ingredient>
       <ingredient>salt</ingredient>
        <ingredient>coriander (cilantro) to garnish</ingredient>
  </ingredients>
   <directions>
         <direction>Mix together the cumin seeds, chilli powder and pepper and rub into the fish.</direction>
<direction>Heat the oil in a frying pan, add the garlic and ginger and heat until they sizzle.</direction>
<direction>Add the salmon fillets and fry until they start to colour (about 15-20 seconds on each side).  </direction>
<direction>Stir in the cream, yogurt, saffron, cardamom and salt.</direction>
<direction>Adjust the heat so that the sauce is just bubbling and cook, turning the fish once, until the flesh just flakes when tested with the point of a sharp knife (about 3-4 minutes each side).</direction>
<direction>Transfer the fish to a shallow dish. Boil the sauce until it has reduced and thickened, pour over the fish and leave to cool.</direction>
        <direction>Cover the dish and chill until 15-20 minutes before serving.</direction>
<direction>Garnish with coriander (cilantro).</direction>
</directions>
</recipe_body>

     <recipe_footer>
           <serving>4</serving>
           <preparation_time>15 minutes</preparation_time>
     </recipe_footer>
      <document_info>
   <document_author>pradeep</document_author>
   <date_updated>12/00311</date_updated>
   <source>Easy to Cook, Hot and Spicy</source>
   </document_info>
  </recipe>
</recipes>

Sunday 13 March 2011

Evolution of SOA

First of all we should know actually what is Software Oriented Architecture "SOA" according to OASIS :

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.

Or we can say that, "SOA" i.e. service-oriented architecture is a collection of services those communicate with each other. One or more than one web services can involve in communication to coordinate some activities or services.

If we look back in 90s, the first service-oriented architecture for many people was with the use DCOM or Object Request Brokers (ORBs), ORB is a part of middleware s/w that allows programmers to make program calls from one computer to another via a network in distributed computing and ORBs can handle the transformation of process data structures to and from the byte sequence while processing, which is transmitted over the network. This is called marshalling or serialization. But they had some problems, like in retrieve data required by others, for this he has to develop new S/Ws, to overcome this problem, the services has been improvised. Then XML language came under existence in SOA thing to communicate between different entities.

SOA requires loose coupling of services with OS, and other , to separates functions into different units, or services, that can easily accessible by developers for reuse and production of applications.

  • Basically SOA is for building business applications.
  • It is a black-box component architecture.
  • Components of SOA is loosely coupled.
  • SOA components are arranged in a manner that link together through processes to deliver a well defined level of service.

Wednesday 9 March 2011

DTD AND XML

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE trainlog[
<!ELEMENT trainlog (session+)>

 <!ELEMENT session (duration, distance, location, comments)>
  <!ATTLIST session
    date CDATA #IMPLIED
   type (running | swimming | cycling) "running"
   heartrate CDATA #IMPLIED>

 <!ELEMENT duration (#PCDATA)>
 <!ATTLIST duration
   units (seconds | minutes | hours) "minutes">

 <!ELEMENT distance (#PCDATA)>
 <!ATTLIST distance
   units (miles | kilometers | laps) "miles">

 <!ELEMENT location (#PCDATA)>

 <!ELEMENT comments (#PCDATA)>
 <!ENTITY WP "Warner Park">
 <!ENTITY  NTP "Natchez Trace Parkway">

]>
 <trainlog>
   <session date="11/19/05" type="running" heartrate="158">
     <duration units="minutes">50</duration>
     <distance units="miles">5.5</distance>
     <location>&WP;</location>
     <comments>Mid-morning run, a little winded throughout.</comments>
   </session>

   <session date="11/21/05" type="cycling" heartrate="153">
     <duration units="hours">1.5</duration>
     <distance units="miles">26.4</distance>
     <location>&NTP;</location>
     <comments>Hilly ride, felt strong as an ox.</comments>
   </session>
 </trainlog>

car.dtd

<?xml version = "1.0" encoding = "utf-8"?>
<!ELEMENT cars(ad+)>
<!ELEMENT ad(make,model,year,color,engine,number_of_doors,transmission_type,accessories)>
<!ELEMENT make(#PCDATA)>
<!ELEMENT model(#PCDATA)>
<!ELEMENT year(#PCDATA)>
<!ELEMENT color(#PCDATA)>
<!ELEMENT engine(#PCDATA)>
<!ELEMENT number_of_doors(#PCDATA)>
<!ELEMENT transmission_type(#PCDATA)>
<!ELEMENT accessories(#PCDATA)>

<!ATTLIST accessories radio CDATA #REQUIRED>
<!ATTLIST accessories air_conditioner CDATA #REQUIRED>
<!ATTLIST accessories power_window CDATA #IMPLIED>
<!ATTLIST accessories power_steering CDATA #IMPLIED>
<!ATTLIST accessories power_brake CDATA #IMPLIED>

train_info.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE rail_info SYSTEM "rail_info.dtd">
<?xml-stylesheet type="text/css" href="rail_info.css"?>
<rail_info>

<train_info>
<title1>Information about the trains</title1>

<train>
<type>SuperFast</type>
<name>GaribRath</name>
<no>12495</no>
<source>Delhi</source>
<dest>Patna</dest>
</train>
</train_info>

<station_info>
<title2>Information about the station</title2>
<station>
<name>Patna</name>
<code>pnbe</code>
<zone>North East</zone>
<no_train_stop>50</no_train_stop>
<no_train_pass>50</no_train_pass>
</station>
</station_info>

<zone_info>
<title2>Information about the zone</title2>
<zone>
<name>North East</name>
<code>ne</code>
<no_of_st>100</no_of_st>
</zone>
</zone_info>

</rail_info>


train_info.dtd
<!ELEMENT rail_info (train_info,station_info,zone_info)>
<!ELEMENT train_info (title1,train+)>
<!ELEMENT train (type,name,no,source,dest)>
<!ELEMENT station_info (title2,station+)>
<!ELEMENT station (name,code,zone,no_train_stop,no_train_pass)>
<!ELEMENT zone_info (title3,zone+)>
<!ELEMENT zone (name,code,no_of_st)>
<!ELEMENT type (#PCDATA)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT no (#PCDATA)>
<!ELEMENT source (#PCDATA)>
<!ELEMENT dest (#PCDATA)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT code (#PCDATA)>
<!ELEMENT zone (#PCDATA)>
<!ELEMENT no_train_stop (#PCDATA)>
<!ELEMENT no_train_pass (#PCDATA)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT code (#PCDATA)>
<!ELEMENT zone (#PCDATA)>

rail_info.css

rail_info
{
background-color: #ffffff;
width: 100%;
}
train_info,station_info,zone_info,train,station,zone
{
display: block;
margin-bottom: 30pt;
margin-left: 0;
}
title1,title2,title3
{
color: #FF0000;
font-size: 20pt;
}
type,name
{
color: #0000FF;
font-size: 20pt;
}
code,no,source,dest,zone,no_train_stop,no_train_pass,code,no_of_st
{
display: block;
color: #ff0;
margin-left: 20pt;
}

XML AND DTD(news.xml)

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE NEWSPAPER [

<!ELEMENT NEWSPAPER (ARTICLE+)>
<!ELEMENT ARTICLE (HEADLINE,BYLINE,LEAD,BODY,NOTES)>
<!ELEMENT HEADLINE (#PCDATA)>
<!ELEMENT BYLINE (#PCDATA)>
<!ELEMENT LEAD (#PCDATA)>
<!ELEMENT BODY (#PCDATA)>
<!ELEMENT NOTES (#PCDATA)>

<!ATTLIST ARTICLE AUTHOR CDATA #REQUIRED>
<!ATTLIST ARTICLE EDITOR CDATA #IMPLIED>
<!ATTLIST ARTICLE DATE CDATA #REQUIRED>
<!ATTLIST ARTICLE EDITION CDATA #IMPLIED>

<!ENTITY NEWSPAPER "Vervet Logic Times">
<!ENTITY PUBLISHER "Vervet Logic Press">
<!ENTITY COPYRIGHT "Copyright 1998 Vervet Logic Press">

]>
<NEWSPAPER>
<ARTICLE AUTHOR="Ravi" EDITOR="Tom" DATE="5/2/11" EDITION="vol32">
<HEADLINE>INDIA WINS THE MATCH</HEADLINE>
<BYLINE>&PUBLISHER;</BYLINE>
<LEAD>ANUJ &NEWSPAPER;</LEAD>
<BODY>INDIA BEAT DUTCH</BODY>
<NOTES>&COPYRIGHT;</NOTES>
</ARTICLE>
<ARTICLE AUTHOR="Eric" EDITOR="Robert" DATE="8/2/11" EDITION="vol39">
<HEADLINE>ARSNEL Beat MANU</HEADLINE>
<BYLINE>&PUBLISHER;  </BYLINE>
<LEAD>ANUJ &NEWSPAPER;Eric Donald</LEAD>
<BODY>INDIA BEAT DUTCH</BODY>
<NOTES>&COPYRIGHT;</NOTES>
</ARTICLE>
<ARTICLE AUTHOR="ROss" DATE="24/2/11">
<HEADLINE>Nickel back new album </HEADLINE>
<BYLINE>&PUBLISHER; </BYLINE>
<LEAD>ANUJ &NEWSPAPER;Kyra  Jhonson</LEAD>
<BODY>Someday Hit song</BODY>
<NOTES>&COPYRIGHT;</NOTES>
</ARTICLE>
</NEWSPAPER>



INLINE declaration of DTD with in XML document

Tuesday 8 March 2011

EXE 7.1, 7.2

cars.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE cars SYSTEM "cars.dtd">

<cars>
    <car>
        <make> suzuki </make>
        <model> swift </model>
        <year> 2010 </year>
        <color> white </color>
        <engine>
               <no_of_cylinder> 4 </no_of_cylinder>
               <fuel_system> diesel </fuel_system>
        </engine>
                <no_of_doors> 4 </no_of_doors>
        <transmission_type> paddle shift </transmission_type>
        <accessories  radio="no"
                     air_conditioning="no"
                     power_windows="no"
                     power_steering="yes"
                     power_brakes="yes">accessories </accessories>
      </car>
       <car>
        <make> honda </make>
        <model> honda city </model>
        <year> 2008 </year>
        <color> red </color>
        <engine>
               <no_of_cylinder> 4 </no_of_cylinder>
               <fuel_system> petrol </fuel_system>
        </engine>
        <no_of_doors> 4 </no_of_doors>
        <transmission_type> tiptronic </transmission_type>
        <accessories  radio="yes"
                            air_conditioning="no"
                     power_windows="yes"
                     power_steering="no"
                     power_brakes="yes">accessories </accessories>
      </car>
 </cars>

cars.dtd

<?xml version="1.0" encoding="UTF-8"?>
<!ELEMENT cars(car+)>
<!ELEMENT car(make,model,year,color,engine,no_of_doors,transmission_type,accessories)>
<!ELEMENT make(#PCDATA)>
<!ELEMENT model(#PCDATA)>
<!ELEMENT year(#PCDATA)>
<!ELEMENT color(#PCDATA)>
<!ELEMENT engine(no_of_cylinders,fuel_systems)>
<!ELEMENT no_of_cylinders(#PCDATA)>
<!ELEMENT fuel_systems(#PCDATA)>
<!ELEMENT no_of_doors(#PCDATA)>
<!ELEMENT transmission_type(#PCDATA)>
<!ELEMENT accessories(#PCDATA)>
<!ATTLIST accessories radio CDATA #REQUIRED>
<!ATTLIST accessories air_conditioning CDATA #REQUIRED>
<!ATTLIST accessories power_windows CDATA #REQUIRED>
<!ATTLIST accessories power_steering CDATA #REQUIRED>
<!ATTLIST accessories power_brakes CDATA #REQUIRED>


Ex 7.2 DTD document for car catalog

<?xml version = "1.0" encoding = "utf-8"?>
<!ELEMENT cars(ad+)>
<!ELEMENT ad(make,model,year,color,engine,number_of_doors,transmission_type,accessories)>
<!ELEMENT make(# PCDATA)>
<!ELEMENT model(#PCDATA)>
<!ELEMENT year(#PCDATA)>
<!ELEMENT color(#PCDATA)>
<!ELEMENT engine(number_of_cylinders,fuel_system)>
<!ELEMENT number_of_doors(#PCDATA)>
<!ELEMENT transmission_type(#PCDATA)>
<!ELEMENT accessories(#PCDATA)>

<!ATTLIST accessories radio CDATA #IMPLIED>
<!ATTLIST accessories air_conditioner CDATA #IMPLIED>
<!ATTLIST accessories power_window CDATA #REQUIRED>
<!ATTLIST accessories power_steering CDATA #REQUIRED>
<!ATTLIST accessories power_brake CDATA #REQUIRED>

Ex 7.1 xml document

<?xml version = "1.0" encoding = "Utf-8"?>
<!DOCTYPE cars SYSTEM "cars.dtd">
<cars>
 <ad>
   <make>Toyoto</make>
   <model>Corolla</model>
   <year>2000</year>
   <color>black</color>
   <engine>
        <number_of_cylinders>2</number_of_cylinders>
        <fuel_system>4 stroke petrol</fuel_system>
   </engine>
   <number_of_doors>4</number_of_doors>
   <transmission_type>continously variable</transmission_type>
  
   <accessories radio = "yes"
                air_conditioner = "yes"
                power_window = "no"
                power_steering = "no"
                power_brake = "no">accessories </accessories>
 </ad>

 <ad>
   <make>Cheverlet</make>
   <model>Tavera</model>
   <year>2000</year>
   <color>red</color>
   <engine>
        <number_of_cylinders>4</number_of_cylinders>
        <fuel_system>4 stroke diesel</fuel_system>
   </engine>
   <number_of_doors>4</number_of_doors>
   <transmission_type>dual clutch</transmission_type>
  
   <accessories radio = "yes"
                air_conditioner = "yes"
                power_window = "yes"
                power_steering = "no"
                power_brake = "no">accessories</accessories>
 </ad>
</cars>

Sunday 6 March 2011

MASH-UP !!!

First of all, i would like to explain the term MASHUP means mixing or remix, here it is a combination of tools or we can say data from other sources or web pages. Mash-ups collect data from multiple web pages and collect required information into one web application. In simple words , A web mash-up is a web application that collect information from one or more sources and provide information in a unique layout . There are number of ways for mash-ups to use in required manner and mash-ups are like endless.

To create a mash-up, many different sources are required and usually that sources have an XML based module for make compatibility to provide data for mash-ups. This allows the mash-up to use these XML outputs as inputs. Once the required data got collected and combined , the mash-up will generate its own output after manipulate them, which displays a combination of the original data from other sources.

In Web development, a mashup is a Web page or application that uses and combines data, and to create new services it uses functions and way of presentation from other sources. The main characteristics of the mashups are combination, visualization, and aggregation.

In the past years, number of Web applications have published application programming interfaces that enable developers to integrate data and functions easily , in place of building them by themselves. We can say that Mashups played an active role for evolution of social software and Web 2.0. Generally mashup do not require programming skills and support services .

There are many types of mashups, such as

  • Business mashups
  • Consumer mashups
  • Data mashups

Mashups are a field of interactive Web applications that based upon content retrieved from external data sources to create new and innovative services. This blog explores what it means to be a mashup, the different classes of mashups and their applications already constructed today.

Wednesday 2 March 2011

Evolution of SOA

Earlier programmers find it difficult to write more complex programs so they required a better way to reuse the code than rewriting so they opted modular design but they needed higher level of abstraction so object oriented design was evolved. Component-based software was a good solution for reuse and maintenance, but it doesn't address all of the complexities  faced by developers.

SOA  provides a solution to all of the above by eliminating the problems of protocol, platforms and integrated applications.

The key components of SOA are:

Services
Messages
Dynamic discovery
Web services


 SOA, in combination with web services reduces complexity. Application integration is one of the major issues companies face today SOA can solve  System availability, reliability, and scalability. 





Evolution of SOA

The main reason which led to the evolution of SOA is the difficulty faced by the programmers in writing the software. In the early days the programmers were rewriting the exiting piece of code, to over come this disadvantage modular design principles were introduced. Even though this code can be reused with this technology, it led to the maintenance and deployment problems.

To solve this problem classes and object-oriented techniques were introduced. This also led to the reuse of just code and not the functionality of the program. Component based approach is introduced to reuse the functionality. Todays software development faces the problems like distributed software,application integration, varying platform, varying protocols.

All above problems could be solved by using SOA. SOA has following components service, message, dynamic discovery and web services.








Mashup

A mashup  is a Web application that combines multiple services into a single application.

The main characteristics of the mashup are combination, visualization, and aggregation. Mashup makes existing data more useful for personal and professional use.

The first mashup application was  used to map services or photo services to combine these services with data of any kind.
There are many types of mashup such as
  Data mashups
  Consumer mashups
  Enterprise mashups.               


 Data mashups combine similar types of media and information from multiple sources into a single representation.

Consumer mashups combines different data types such as visual elements and data from multiple sources .

Business mashups  applications  combines their own resources, application and data, with other external Web Services.
The architecture of a mashup is divided into three layers:
  • Presentation: It defines user interface by adopting technologies like HTML,CSS Javascript and AJAX.
  • Web Services: The functionality can be accessed using the API services and technologies like RPC, SOAP,REST.
  • Data: Handling of data like sending, storing and receiving are  performed using technologies like XML and JSON.







Web Services and Web Applications

Lets first see what they actually mean.

Web services provide a standard means of interoperation between different software applications, running on a variety of platforms and/or frameworks. In a broader sense it means: " A Web service is a software system designed to support interoperable machine-to-machine interaction over a network. It has an interface described in a machine-processable format (specifically WSDL). Other systems interact with the Web service in a manner prescribed by its description using SOAP messages, typically conveyed using HTTP with an XML serialization in conjunction with other Web-related standards."

The purpose of a Web service is to provide some functionality on behalf of its owner -- person or organization, such as a business or an individual. 
Web services are sometimes called application services. Web services are not directly meant for the users but for the developers to aggregate/integrate the different services from different services providers to give users the flexibility to use various services on a single web application.
These services may be checking someone's credit, checking the inventory status or checking shipping status for a logistics firm.
AMAZON is the pioneer in web services frontier these days.

Now lets see what is a web application.
A web application is an application that is accessed over a network such as the internet or an intranet. 

A web application is a self-contained subtree of the web site. It uses Servlets, Filters, JSP, and the functionality provided by any other java code to provide a response to a client that makes an HTTP request.

Any application that uses a web browser as a client is actually a web application.
For example, a web site with a sign-in for the users or a web site with a message board 

Mashups

A mashup is a type of  application that's comprised of two or more  components that have
 been connected to create a new integrated experience.Mashups are generally client applications or hosted online.The term implies easy, fast integration, frequently using open APIs.Mashup is important to make existing data more useful, moreover for personal and professional use.standardizing key technologies, such as SOAP, REST, and Ajax, we've seen an explosion in the adoption of SOAs, both on the Web and inside the enterprise. This has led to the technologies reaching a critical mass whereby there is aincreased  reusable Web-based APIs and mashups . In this, there's an  expanding set of content, data, and services available for people who wish to develop applications using this model.
--------------------------------------------------------------------------------------------------------------
1) IBM® Mashup Center
IBM® Mashup Center is an enterprise mashup platform enabling the rapid creation, sharing, and discovery of reusable application building blocks (widgets, feeds, mashups) that can be easily assembled into new applications or leveraged within existing applications - with the governance and security IT requires
http://www.ibm.com/developerworks/downloads/ls/lsmashupcenter/index.html

2)IBM mashup technology on YouTube.
--------------------------------------------------------------------------------------------------------------

Evolution of SOA!!!

SOA is a revolutionary shift from client server architecture ,SOA emerged into IT mainstream when web services became the  basis of a seperate architectural platform.

The IT industry has decomposed IT infrastructures into modular, reusable services.Evolution of the SOA will put these services in the hands of the users (non-developers) so they can build solutions in a manner that can overcome various  problems.We need a new way of accessing and leveraging the current services in the SOA and empowering the end or business user to quickly integrate the services together. This approach would allow them to rapidly create applications that meet their situational needs.


Mashup Application

Wikipedia explains Mashup as: 
                                        a mashup is a web page or application that uses and combines data, presentation or functionality from two or more sources to create new services.
According to Mcmillan Dictionary:
                            a website or piece of software making use of information from more than one websitefor exampleusing photographs from one website and text from another.


Both of the above definition has many thing in common. Both presents Mashup as either a Web Page or Application.
It is also clear that Mashup Application deals with the combination of data and its presentation. Mashup Application is very common and useful in the scenario today. A very famous mashup application is Google Map.


Google provides API, which can be used to add other informations over it. We can today see many of the websites which are based on the google Map Application. In similar ways their are many other application like this.


Mashup Can be of many type e.g.:
Mapping Mashup, Photo and Video Mashup, Search and shopping Mashup, news Mashup( From IBM.COM)



There are many technologies that are being used to implement Mashup Application:


The Mashup Architecture consists of following three participants:
API/content providers, the mashup site, and the client's Web browser.
The API/ content providers are the site from which the data is fetched. The Mashup site is a place where the Mashup is hosted. The place where user interacts with the Mashup Application is Clients Web Browser.


Ajax which is a combination of several technologies is used to create a smooth and cohesive web experience for the user by exchanging small amount of data rather than reloading complete page.


Web Protocols like REST and SOAP are used to create a platform independent environment.


When we focus on the Mashup Application we come to know that this is a very useful and widely used and uses all the latest ways to make the maximum use of them.

Mashup application

Mashups are an exciting genre of interactive Web applications that draw upon content retrieved from external data sources to create entirely new and innovative services. They are a hallmark of the second generation of Web applications informally known as Web 2.0.

In short "In web development a mashup is a web page or application that uses and combines data, presentation or functionality from two or more sources to create new services."

There are many types of mashup, such as data mashups, consumer mashups, and enterprise mashups:
  1. Data mashups combine similar types of media and information from multiple sources into a single representation.
  2. Consumer mashups generally visual elements and data from multiple sources
  3. Business mashups generally define applications that combine their own resources, application and data,with other external web service.
 

SOA

The service oriented architecture is a design paradigm to build computer software as services.Applying the set of well defined guidelines of SOA results in units of software partitioned into operational capabilities, each designed to solve an individual concern.

In order to describe the evolution of SOA first we need to define the problems that were faced by developers and how did they come up with a solution.Early programmers realised that they were not able to reuse code that they coded ,so so came up with a solution called modular design.Then they were cutting and pasting their modules into other applications and that this started to create a maintenance problems when a bug was discovered in a function somewhere, they had to track down all of the applications.

Researchers proposed  object oriented software design  to solve this, and many more, problems. Again, as software complexity grew, developers started to see that developing and maintaining software was complex and they wanted a way to reuse and maintain functionality, not just code.To address the above problem component based software was introduced.

Component-based software is a good solution for reuse and maintenance, but it doesn't address all of the complexities developers are faced with today. Today there are many problems  like distributed software, application integration, varying platforms, varying protocols, various devices, the Internet, etc.

To address these problems SOA was introduced with well defined components,standards.guidelines.


A service in SOA has functionality with three properties:
  1. The interface contract to the service is platform-independent.
  2. The service can be dynamically located and invoked.
  3. The service is self-contained. That is, the service maintains its own state. 












Difference between web application and web service

Web application is a application which is present at the server and the web application uses the web pages as a presentation of content for human users.The data of a web application is stored and manipulated at the server side.In short  the web application resides on a server and it is a collection of web pages  defined using "html,jsp,asp" e.t.c. these can be invoked by a web server like IIS or Apache upon user request.

On the other had a web service provide service to other application and they are not directly used by the end users.It is server based program which cannot be accessed by the client browser and provides for interaction between other application.The web service do not normally have a GUI based interface and used normally by programmers ,web developers to develop other web based application.


Evolution Of Service Oriented Architecture

Service Oriented Architecture is all about collection of services where service is a function which is well-defined,self-contained and does not depend on the context or state of other services.
As we all know Architecture will be the first stage in software creation in which quality requirements can be addressed.
A Service actually forms end-point of a connection and actually describes what we connect together using web services.
So the Web Services purposefully use XML for establishing a robust connection.

The Importance Of XML is described as follows.
  1. XML documents benefit from their hierarchical structure say in a document for example we are willing to move a heading to a new location and drag everything under it along with the heading instead of having to page down to make a selection cut and then paste the selection into a new location.
  2. XML is not a binary format .We can create and edit files using anything from a standard text editor to a visual development environment which makes it easy to debug our programs and it makes XML useful for storing small amounts of data.
  3. XML front end to a database can store large amounts of XML data.So XML provides scalability for small configuration files to a company wide data repository.
  4. XML markup is a meta language which means markup can be used to describe other languages and allows you to create our own XML tags where it provides information about the information for which we are creating the XML based document structure.XML tells about data identification like what kind of data we are accessing.
  5. XML can be easily processed and XML documents can be composed from separate entities which gives a characteristic called In-line Re-usability.



web services vs web application

web servicesweb applications
Service used by web applicationsoftware application hosted on browser Provides GUI for the end users and offers some functionality using web services
Independent of the programming language and the operating systemDependent on the OS and programming language
services can be used by many applications Applications cannot be used by other applications
Technologies used are XML,SOAP,WSDL........HTML,Javascript,Flash,Ajax.......

Evolution of SOA

According to IBM, SOA can be defined in several ways depending upon the point of view:
From the point of view of:SOA is
Business executive and business analystA set of services that constitutes IT assets (capabilities) and can be used for building solutions and exposing them to customers and partners
Enterprise architectA set of architectural principles and patterns addressing overall characteristics of solutions: modularity, encapsulation, loose coupling, separation of concerns, reuse, composability, and so on
Project managerA development approach supporting massive parallel development
Tester or quality assurance engineerA way to modularize, and consequently simplify, overall system testing
Software developerA programming model complete with standards, tools, and technologies, such as Web services
The above set of definitons gives a clear picture of what are the capabilities of SOA, It is seen as set of services, sometime as set of architectural principles. Each has their own way to look into this.

To begin with,lets see what was there before SOA,In the mid and late 90s the evolution of WEB was at its peak(DOT COM boom), People started looking at the WEB as a good platform for extending their business, Many of them ported their business as web application, but this has its own limitations, In beginning, these web application were built as single Monolithic application, the underlying architecture was Client Server architecture. The user used to interact though this application to access the server.

This has got several problems, like access to the data required by others, this lead to development of new softwares like screen scrapping. But this was not the complete solution to the problem. To overcome this problem, the services has been improvised, these were the API to the various application needed.

But now the problem was how to access this. Due to the different specifications and standard being used. The direct interaction was not possible. To overcome this broker agents were introduced. But this was not able to solve the comlete problem of consistency. 
To overcome this,the new architecture has been introduced SOA. This uses XML based language for the communication between different identity. The SOAP is used for the communication between the service provider and the requester of that service. WSDL is used for describing the services provided by the various service providers. UDDI is used to describe and integrate them.

The SOA is playing important role in integrating the various services, as it is platform independent. Many organizations e.g. W3C, OASIS are working in the direction of standardization of the architecture and specification of SOA. Many companies like Microsoft, IBM, Sun Microsystems are also trying to make a standard for these.

web service???

Basically providing services on the web, using technologies like XML, SOAP, WSDL and UDDI  over an Internet protocol backbone.XML is used to tag the data, SOAP is used to transfer the data, WSDL is used for describing the services available and UDDI is used for listing what services are available.web services do not provide GUI to the user instead it shares business logic, data and processes through a programmatic interface across a network.Application developers add GUI to web services to provide some functionality for users.web services are not tied to any OS or programming language.  
------------------------------------------------------------------

Web Services Toolkit

A software development environment for designing, developing, and executing Web service technologies
http://www.alphaworks.ibm.com/tech/webservicestoolkit
------------------------------------------------------------------

Difference Between Web Applications and Web Services

According to definition Web services are that provide a standard means of inter-operating between different software applications, running on a variety of platforms and/or frameworks Web services are all about making different types of applications compatible to inter operate with other.

We can say that web services are mechanism to access remote objects or functions by using HTTP and XML in combine called SOAP(simple object access protocol). Soap has some

methods to access programmable application by some logic and methods.

Web services use soap protocol while web application use http protocol.

Clients are only have to deal with send and get for xml request using SOAP and web applications are accessible by clients.

Web services can be implemented at any client or server place to make data secure, so that when w

eb services are being use on server side,

even programmer also can not find that data.

For an example, a Web Application as defined in Java is a formal way of packaging Servlets where a "Web Service" is a single service which usually communicates with other components through SOAP messaging. Thus a "Web Services" is much closer to an Java Beans than to a whole "web application".

Web services are well defined functions having standard interfaces that just expose a behavior where web applications are browser based applications that also include an interface and functions that are bound into a single application that is run from the web. A web service, however is also an application whose purpose is to serve a service to clients or users.

A web application is like a web site. You can log onto to it, browse, do things etc and consumers are people.

Mashup Applications

The terms Remix and Mashup actually came from the music world.Remix is actually the same song sung to an new or updated beat.Mashup is similar to Remix where in the music world two elements are combined to form a different effect of that song that's actually called mashup.
So now coming back to actual field where Mashup,a web application based technology which actually combines data and services from various sources to create new application.
Some examples of the companies which currently use Mashups are Google,Yahoo,Amazon,eBay,Flickr as well as many online news services and social networking sites.
A simplest form of mashup is shown in the figure.
(Reference:Amazon.com Mashups by Francis Shanahan)


The working procedure in steps is as follows:
Step 1 : The Web browser communicates with the server which actually requests  a page using HTTP or HTTPS.
So actually there are two requests which is being handled one is Amazon and the other one is Yahoo.
Step 2 :  So the page is constructed by the Web Server and the first request which is Amazon is handled by using the SOAP over HTTP.
Step 3 : Amazon returns back a SOAP response.
Step 4 : The second request is Yahoo by using a Representational State Transfer (REST) style approach.
Step 5 : Yahoo will respond with Plain Old XML over HTTP.
Step 6 : Finally the web server takes up the responses and combines the data which makes some sense.
Step 7 : So the resulting data will be in HTML and which is inserted into the response and lastly sent back to the browser.
                  

service oriented architecture

It is an architecture which helps in transformation of business into services and these services can be accessed using internet.services from geographically distributed places can be combined to form a single service.Entry points for SOA are people,process,information,connectivity and reuse of services.

About mashup apps...

Mashup apps is a web apps hybrid where actually which uses and combines data,presentation or functionality from two or more sources to create a new service..
The main use of mashup is that the existing data can be made more powerful and professional.The mashup can exist in different kinds.lets see that:

1)Data mashups:This kind of mashup leads to entirely new kind of web service which was not provided by either source.

2)Consumer mashups:In this kind,the different data types is combined.

3)Business mashups:This generally defines apps that combine thier own resources,application and other data with external web services.it means this also results in some new view of business representation by using their old application views..

Web Services

Web Services are actually the services that are deployed on the web. A Web service is a method of communication between two electronic devices on the network. Its a way of calling methods/functions in an application on the web from another application.

Web Services are an implementation of SOA.
In SOA there are mainly two actors, one is the service provider or producer and the other is the service requestor  or consumer. The consumer sends a request for the service and the producer serves the request with a response. The main characteristic of a web service architecture is that the service providers publish their service description which are placed in a service directory(think of this directory as the popular yellow pages). The consumers on the other hand perform a query against this directory to find what services are available and how to communicate with that provider.

Web services are the APIs on the web which allow applications to communicate with each other using XML, a meta data and using SOAP as protocol.

The heart of the web services are:
  • WSDL(Web Services Description Language)
  • SOAP(Simple Object Access Protocol) and
  • UDDI(Universal Description, Discovery and Integration registry).

Let me briefly explain what they actually are.
WSDL is an industry accepted standard for defining an interface to a service i.e., the service descriptions are to be written in this standard language before they are placed in the service directory.
SOAP defines the protocol - on the network - for making requests and receiving responses.
Finally UDDI, is a standard for registering and searching web services within the service directories - yellow pages as it were - containing web services. Thus UDDI enables searching/discovery of various web services.

Web services are standardised by the W3C with the use of XML(eXtensible Markup Language) tags which form the basis for the web services. XML is actually designed to carry data and not display the data in a browser.