Teaching Web Services and XML with the Water Language Christopher Fry Clear Methods, Inc. Ed...

Teaching Web Services and XML with the Water Language

Christopher FryClear Methods, Inc.

Ed Gehringer and Matt KendallNorth Carolina State University

The Water Logo is trademark 2001-2005 by Clear Methods, Inc.

Agenda

~ Teaching Web services

~ Introduction to Water~ ConciseXML~ Things~ Servers~ Steam IDE

~ The Water object model


Introduction: Web-services example

~ A new airline, Web Air, would like to add car rental services to their on-line ticket sales system.

~ The Web Air reservation system operates off of a database of flight information: no knowledge of rental cars.

~ Web Air’s ticket system must obtain rental data from rental car agencies.

~ What problems could Web Air encounter in gaining this information?


Introduction: Web Air Problems

~ Rental companies may operate on different platforms. Example: Mainframes vs. Linux clusters.

~ Individual rental companies may format rental car information differently. Example: Using RGB values to indicate the color of a car, vs. using a string value.

~ Rental companies may use proprietary formats to store data. Example: A binary format created for an individual company.

~ Access to the data may occur over antiquated or proprietary protocols. Example: Using Solaris remote procedure calls to access the data.


Introduction: Web Services~ One way to simplify data sharing is to apply

standards to interactions between the systems involved.

~ Web services use a set of standards to simplify machine-to-machine communications.~ XML for both input and output.

~ Web Air’s ticket system only needs to understand XML.~ Gets XML data from vendors.


Web Services: Interfaces

~ Standards require that the interface for each Web service be published.

~ The interface is a contract that specifies the available inputs, the formatting of outputs, and the protocols that the Web service employs to transmit data.

~ The protocols employed by Web services are Internet standards such as HTTP, FTP, and SMTP.


Web Services: Interfaces (2)

~ Since inputs and outputs are well defined, Web Air’s ticket system can:1. Query rental car Web services using an XML query generated

based on the published interface.

2. Receive the XML response from the rental car Web service.

3. Use the known interface to translate the data from each rental car agency into a format that it can use internally.


Teaching Web services• Web services are hard to teach. Why?

– Implementation is complex• SOAP• WSDL• Which platform? J2EE? .NET?

– Syntax-to-concept mapping• The good (human language capacity)• The bad (lousy, non-uniform syntaxes)• The ugly (multiple incompatible languages)

– How do we educate students about Web services,• Rather than train them in a specific technology?

Why Teach with Water?

• Supports Web services natively.– So we are teaching the concepts.

• Can return responses in XML, HTML, or SOAP– So we don’t have to spend time on libraries.

Agenda





Introduction to Water

~ Water (http://www.waterlanguage.org) is an open, all-purpose language designed for XML Web services.

~ It provides a simple yet powerful way of writing Web services by supporting XML within its core.


http://www.waterlanguage.org/

Introduction (2)

~ Without Water, XML is used on the "outside"—programs are needed to convert into and out of XML.

~ Water is a language specifically designed for XML. It allows the option of using XML for everything: presentation, logic, content, modeling, etc.


ConciseXML~ XML is, by default, a very verbose method

of representing data.

~ Water uses an extension of XML, ConciseXML, to reduce the amount of text required to represent data in XML.

~ All XML is valid ConciseXML, because ConciseXML is an extension.

~ Not all ConciseXML is valid XML.


ConciseXML: Tag Shorthand

~ Closing tags can be notated as </>.

~ XML 1.0:

<text>Hello!</text>~ ConciseXML:

<text>Hello!</>


ConciseXML: Positional Arguments

~ Water uses XML tags to make method calls with XML attributes as parameters.

~ Methods are predefined, there is no need to specify the attributes as key=value pairs.


ConciseXML: Positional Arguments (2)

~ The key is simply omitted.

~ XML 1.0:

<person first="Ed" last="Gehringer"/>

~ ConciseXML:

<person "Ed" "Gehringer"/>


ConciseXML: Path Notation

~ Representing nested logic is complex in XML.~ ConciseXML simplifies nesting by supporting

a dot notation."abe".<foo color="blue"/>.bar

~ ConciseXML is designed to allow XML to better represent data and logic by removing both verbosity and ambiguity from the language.


ConciseXML: Path Notation (2)

XML 1.0:<execute_path> "abe" <foo color="blue"/> bar</execute_path>ConciseXML:"abe".<foo color="blue"/>.bar


Things

• Like many object oriented languages, everything in Water is an object.

• The most generic class in Water is a thing.

~ Objects in water have a set of properties, called fields.

~ We can create a thing without fields:

<thing/>


Things (2)

<thing shape="square" size=10/>~ Creates a thing with the fields shape and

size.~ ConciseXML does not require parameter

names, but we have provided them here. ~ What happens when we execute the

following Water code?

<thing "square" 10/>


Things (3)

~ We can use the path notation provided by ConciseXML to select a specific field:<thing x=10 y=14 z=-4 message=<h1>A Point P</> />.z

~ What value does this code fragment return?~ Notice that the message field in the above thing contains an

<h1> object.~ Also note that the <h1> object’s tag has a body, i.e. it is not

an empty tag, unlike the thing objects we have seen so far.~ This means that Water can support seemingly unstructured

content in the body of object tags.


-4

Things (4)

~ Water applies a structure to the content of each tag.<h1>A large <thing "header"/> object!</>.0<h1>A large <thing "header"/> object!</>.1<h1>A large <thing "header"/> object!</>.2

~ What will each statement return?


Servers

~ Methods are easy to define in Water.

~ This simple method returns a thing with the specified fields.

<defmethod foo>

<thing

"bar"

<thing "foo" "bar"/>

<h1>Foo Bar!</>

/>

</>


Servers: Executing a Method

~ We can create a server that will execute our method:

<server root=foo port=8000/>~ We can execute this method by visiting

http://localhost:8000/?.

~ The question mark (?) is included because we want to execute <foo>.

~ What happens if we visit http://localhost:8000 without the question mark?


http://loaclhost:8000/?

http://localhost:8000/

Servers: Parameters

~ We can also provide required parameters in the request.

~ This Water program defines a method <foo> that has a required parameter x. Foo creates a thing with a field value that equals x.

~ What will happen if we execute http://localhost:8000/?x=42?

<defmethod foo x=required>

<thing value=x/>

</>

<server root=foo port=8000/>


http://localhost:8000/?x=42

Servers: Omitting a Parameter

~ What if we execute http://localhost:8000/? now?

~ What about the message returned by the server reminds us of our previous studies of Web services?

<defmethod foo x=required>

<thing value=x/>

</>

<server root=foo port=8000/>


http://localhost:8000/?

Servers: Calling from Programs

~ So far, all the services we have called have been invoked from a browser. It is also possible to call a Web service from a program.

~ This code snippet will execute the method <foo> with x="Hello World!“

<set mything=

<web

"http://localhost:8000/"/>

/>

<mything x="Hello World!"/>


Servers: Local Invocation

~ Of course, for local methods such as <foo>, we can also execute:

<foo "Hello World!"/>


Steam IDE

~ Water source files can be edited in any text editor, but the Steam IDE is designed to write Water programs.

~ Code is executed by highlighting a statement and pressing the execute button.

~ Once code is executed, its effects remain in the environment until they are changed by a later execution.


Steam IDE (2)

<set myvar=<h1>Execution One</> />~ The variable myvar is assigned the <h1> object.~ If at a later time you execute:

<echo myvar/>~ The value of myvar is retained from the previous

execution.~ This retention of the environment allows for

rapid, iterative development.


Steam IDE (3)

~ Objects can be inspected by double-clicking on their name in the editing pane.


Agenda





The Water object model

~ The Water object model is simple, yet extremely powerful. It can be described in four statements.~ Everything is an object.~ An object has fields.~ Each field has a key and a value.~ The key and value can be any object.


An Object

~ Consider this object:

<thing a=2.7 343 s="This is a string" d=<thing 10 20/> />

~ How many fields does it have?

~ What are the keys?

~ What are the values?


4a, s, d

2.7, 343, "This is a string", <thing 10 20/>

Classes & Methods

~ Recall that Web services must publish a well defined interface, or contract, that defines their inputs and outputs.

~ Water contracts are based on class and method definitions.

~ Classes are created using <defclass/> and methods are created using <defmethod/>.


Classes & Methods: Classes

~ We can easily create a class in Water:

<defclass myclass one two/>~ This expression defines a class called <myclass> that has two fields: one and two.


Classes & Methods: Classes (2)

~ We can create new instances of <myclass>.

~ What is the only requirement of this myclass contract?

<myclass "my first field" "my second field"/>

<myclass <thing "0"/> 1/>

<myclass <thing 0 1/> null />



~ We can further define the contract by supplying each field with a type.

~ <myclass> now expects to receive a number for field one and a string for field two.

<defclass myclass one=required=number two=required=string

/>



~ What are the values of one and two for each of the following statements?

<myclass/>

<myclass 3/>

<myclass two="2"/>



~ So far, we have created instances of classes but we have not saved them.

~ You can store an instance into a variable:

<set myvar=<myclass 4 "foo"/> />


Classes & Methods: Methods

~ Method definitions are similar to class definitions.

<defmethod foo>

"bar"

</>

~ Method parameters use all of the same contracts as class parameters.

<defmethod foo one=required=number two="2">

"bar"

</>


Classes & Methods: Methods (2)

~ The value of the last statement executed in a method is the value returned by the method.

~ Methods can specify their return type:<defmethod foo x=required=string _return_type=string>

x.<concat "-bar"/>

</>

~ This method concatenates the string supplied for x with the string literal "-bar".



~ Methods can be declared as members of a class.

~ What is the purpose of _subject in this code?

<defclass person first last>

<defmethod hire>

_subject.<set hired_on=date.<current/>

</>

</>



~ It is also possible to assign methods outside of the class definition.

~ If a method is defined outside of a class, we have the option of assigning it to a class.

~ What class is the method accessible from if we do not explicitly assign it to a class?

<defclass person first last/>

person.<defmethod hire>

_subject.<set hired_on=date.<current/>

</>



~ For example, from what classes could the following method be invoked from?

<defmethod describe>

_subject.<to_string/>.<concat _subject.<keys/>.<to_string/> />

</>

~ What does this method do?


Classes & Methods: Invoking [1]

~ In Water, a call is either a method call or a constructor call. The syntax is the same.

~ In the following example, the first line creates a method named foo_method.

~ The second line calls the method with the argument x="test". The method call executes the method implementation and returns the result.<defmethod foo_method x> x</><foo_method x="test"/>

~ What is the result of the above execution?


Classes & Methods: Invoking (2)

~ You can also invoke a method on a subject:

<defmethod tag_it value>

_subject.<set tag=value/>

</>

thing.<tag_it "You're it!"/>

thing.tag


Classes & Methods: Invoking (3)

~ Or, you can declare a method as a member of a specific class (instead of thing) and invoke it on the owning class and its subclasses:<defclass game>

<defmethod tag_it value>

_subject.<set tag=value/>

</>

</>

<set a_game=<game/> />

a_game.<tag_it "Freeze!"/>

a_game.tag


Classes & Methods: Creating

~ Now consider the following example of creating an object instance:<defclass foo_object x/><foo_object x="test"/>

~ Notice the identical structure between this instance creation and invoking a method without a target. In this example:

~ The first line creates a class object named foo_object. ~ The second line calls the default initialization constructor

(the init method) for foo_object with an argument x="test".

~ The constructor call executes the init method, which returns the new instance.


Classes & Methods: Creating (2)

~ The init method is Water’s version of a constructor. We can override the init method to perform tasks during object creation.

~ What does _new_object contain?

~ The student class maintains a field called peers. student.peers is a <thing/> that is initially empty, it has no fields.

~ When a new student is created, it is added to the peers object as a new field. The key of the field is the value of student.id. The value is the student object itself.

~ Browse to http://localhost to see the results

<defclass student id name> student.<set

peers=<thing/> /> <defmethod init> student.peers.<set_field

_new_object.id _new_object/>

_new_object </></><student 100 "Bob"/><student 200 "Mary"/><student 300 "Jack"/><server root=student/>


http://localhost/

http://localhost/

Classes & Methods: Creating (3)

~ We have created new instances using local Water expressions, but remember that we can also create new objects based on URLs. For example,

~ http://localhost/student?id=400&name=Tom

~ is identical to

~ <student 400 "Tom"/>


Is Water Easy to Learn?

Sm

allta

lk

Java

Wat

er

Easiest2nd place

Hardest

02468

1012141618

Overall score: Java 58, Water 33, Smalltalk 28

Is Water Perceived to Be Useful?

Overall score: Java 58, Water 40, Smalltalk 25

Sm

allta

lk

Java

Wat

er

Most useful2nd place

Least useful

02468

10

1214

16

Summary

~ Web services are rapidly growing in importance.

~ Water is a good way to learn Web services.~ It is concise.

~ Small Web services can be written in a few lines of code.

~ One can concentrate on the concepts, not the implementation.

Date post:	26-Mar-2015
Category:	Documents
Upload:	sofia-dunlap
View:	221 times
Download:	0 times

Teaching Web Services and XML with the Water Language Christopher Fry Clear Methods, Inc. Ed...

Documents