Given by Geoffrey C. Fox at Tango Seminar to DoD Modernization MSRC on April 6 1999. Foils prepared April 4 1999
Outside Index
Summary of Material
We describe some concepts that will underlie the development of emerging distributed object based systems |
What is the Web Document Object Model and why is Dynamic HTML (DHTML) intriguing and XML critical |
Why is JavaScript non trivial as the language to capture changes in document object structure and to choose appropriate rendering
|
Where do CORBA and Jini fit in? |
We define the Pragmatic Object Web as the emerging synthesis of multiple object models |
We describe the importance of the Web as a source of information objects and as a mechanism for invoking general server side objects |
We stress the important role of both Asynchronous and Synchronous collaboration and the web and web-based collaboration allows one to implement it. |
We use ASC Gateway project as an example of hybrid object systems |
Outside Index
Summary of Material
Online Seminar April 6, 1999 |
http://www.npac.syr.edu/users/gcf/msrcobjectsapril99 |
http://www.w3.org/ |
Geoffrey Fox |
Syracuse University |
NPAC |
111 College Place Syracuse NY 13244 4100 |
3154432163 |
We describe some concepts that will underlie the development of emerging distributed object based systems |
What is the Web Document Object Model and why is Dynamic HTML (DHTML) intriguing and XML critical |
Why is JavaScript non trivial as the language to capture changes in document object structure and to choose appropriate rendering
|
Where do CORBA and Jini fit in? |
We define the Pragmatic Object Web as the emerging synthesis of multiple object models |
We describe the importance of the Web as a source of information objects and as a mechanism for invoking general server side objects |
We stress the important role of both Asynchronous and Synchronous collaboration and the web and web-based collaboration allows one to implement it. |
We use ASC Gateway project as an example of hybrid object systems |
http://www.w3.org/ W3C Consortium for HTML XHTML CSS XML .... |
Dynamic HTML, The Definitive Reference by Danny Goodman (1st ed, O'Reilly, 1998). |
NPAC's Web Resources page, http://www.npac.syr.edu/projects/tutorials/ HREF="http://www.npac.syr.edu/projects/tutorials/HTML/"> |
JavaScript, The Definitive Guide by David Flanagan (3rd ed, O'Reilly, 1998); The JavaScript Bible by Danny Goodman (3rd ed, IDG, 1998); or download the JavaScript manual from |
http://developer.netscape.com/tech/javascript/index.html |
Web Page objects |
General Objects |
Pragmatic Object Web |
Multi Tier Object/Service Arch. |
HTML |
XML and XHTML |
XML as a Database Serialization |
JavaScript/ECMAScript |
Dynamic HTML DHTML |
CSS Cascading Style Sheets |
Document Object Model DOM |
Current DOM: JavaScript plus DHTML |
W3C DOM |
Jini and Service Architecture |
XML as Web Template Language |
CORBA and HPCC Examples |
CORBA and Security |
JWORB Pragmatic Object Web |
Gateway and XML |
Tango Architecture |
Collaborative or Shared Objects |
Universal Access |
Web-linked Databases |
Lotus Notes |
Shared Web Pages are Everything |
JavaScript Shared Browser |
The Object Web Signifies the merger of distributed object and web technologies |
The Pragmatic Object Web asks us to take the best of CORBA (Industry Standard) COM (Microsoft PC Standard) Java (Web Software Infrastructure) and W3C (XML) |
An "object" is an entity that can be
|
The most common object is a Web Page |
The richest available object model is the Web Document Object Model or DOM |
JavaScript is one language to manipulate this DOM |
Web Browsers render this object |
Web Servers broker this object |
As Web Pages are natural user interface to ALL objects, XML extensions to web pages reflects all objects .... |
Contents of (relational) Databases -- give these a web interface and view as an XML (or HTML) stream
|
Computer Programs -- from CGI Scripts to Servlets to CORBA IDL brokered Fortran Programs |
(Large) data resources -- from file systems to archival storage |
Devices -- from toasters, microsensors to surveillance cameras, PC's, Printers, Supercomputers, Telescopes |
Electronic Mail Messages -- favorite form of collaboration |
People |
Define Objects and properties / methods (backend) and define services (frontend) |
Objects (at "backend") can be on client of course |
Broker or Server |
Rendering Engine |
XML |
Result |
XML Query |
User dependent Style Sheets and Rendering engines |
Rendering Engine |
XML result |
HTML |
Objects |
Universal Interfaces |
IDL or Templates |
Web Page objects |
General Objects |
Pragmatic Object Web |
Multi Tier Object/Service Arch. |
HTML |
XML and XHTML |
XML as a Database Serialization |
JavaScript/ECMAScript |
Dynamic HTML DHTML |
CSS Cascading Style Sheets |
Document Object Model DOM |
Current DOM: JavaScript plus DHTML |
W3C DOM |
Jini and Service Architecture |
XML as Web Template Language |
CORBA and HPCC Examples |
CORBA and Security |
JWORB Pragmatic Object Web |
Gateway and XML |
Tango Architecture |
Collaborative or Shared Objects |
Universal Access |
Web-linked Databases |
Lotus Notes |
Shared Web Pages are Everything |
JavaScript Shared Browser |
HTML defines the display or rendering of documents |
HTML 3.2 (Jan 97) introduced tables, applets, and other capabilities (approx. 70 tags) |
The final spec for HTML 4.0 was released by W3C in December 1997 |
There are three flavors:
|
HTML 4.0 has 93 elements (10 deprecated) and 187 attributes (49 deprecated) |
HTML represents an object model for document display |
HTML does NOT define an object model for document content -- XML does this |
The logical design of a document (content) should be separate from its visual design (presentation) |
Separation of logical and visual design
|
HTML mixes the logical with the visual |
Internal Representation of Microsoft Word/PowerPoint will/should be XML while "Save As HTML" should gives its visual rendering in HTML
|
XML = eXtensible Markup Language |
XML is a subset of SGML -- Standard Generalized Markup Language, but unlike the latter, XML is specifically designed for the web |
XML is used to define logical document structure |
XML is not backward compatible with HTML, but the two coexist quite elegantly |
XML can be thought of as an ASCII version of a database |
XML can be used as an object IDL to access databases or any objects and so give web HTML templates to access web-linked databases / backend services |
XML can be used as inter object data (serialization) format for any object model |
XHTML is HTML4 written in XML syntax |
XML is a compromise between the non-extensible, limited capabilities of HTML and the full power and complexity of SGML |
XML Tags are converted to HTML for display (or other XML tags) by one or more Servers or clients |
HTML < XML < SGML |
(CSS) (XSL) (DSSSL) |
XML is a kind of SGML Lite! |
Original |
XML |
New XML |
and perhaps some HTML |
Newer XML |
and perhaps more HTML |
Newest XML |
and perhaps all HTML |
H T M L |
Document Type Definition (DTD), which defines the tags and their relationships |
Extensible Style Language (XSL) style sheets, which specify the presentation of the document |
Extensible Link Language (XLL), which defines link-handling details |
It supports scripting languages such as ECMAScript (JavaScript) or Java |
For example a link can be defined in XML as <LINK> <TITLE>XML Recommendation</TITLE> <URL> http://www.w3.org/TR/REC-xml </URL> <DESCRIPTION> The official XML spec from W3C </DESCRIPTION> </LINK> |
<?xml version="1.0"?> |
<!DOCTYPE BIB SYSTEM "bib.dtd"> |
<references> |
<book>
|
</book> |
<journal>
|
</journal> |
</references> |
XML as serialized version of a bibliographic database |
Notation: is represented as: |
<mrow> |
<mrow>
|
<mrow>
|
</mrow>
|
</mrow>
|
</mrow> |
MathML can be found at W3C WebSite |
Web Page objects |
General Objects |
Pragmatic Object Web |
Multi Tier Object/Service Arch. |
HTML |
XML and XHTML |
XML as a Database Serialization |
JavaScript/ECMAScript |
Dynamic HTML DHTML |
CSS Cascading Style Sheets |
Document Object Model DOM |
Current DOM: JavaScript plus DHTML |
W3C DOM |
Jini and Service Architecture |
XML as Web Template Language |
CORBA and HPCC Examples |
CORBA and Security |
JWORB Pragmatic Object Web |
Gateway and XML |
Tango Architecture |
Collaborative or Shared Objects |
Universal Access |
Web-linked Databases |
Lotus Notes |
Shared Web Pages are Everything |
JavaScript Shared Browser |
JavaScript (originally called LiveScript) is a web scripting language for clients and servers |
Originally JavaScript was designed to do what you think Java should do -- elegant dynamic animation on the client side |
Then along came Java and JavaScript was eclipsed as it was just Netscape and not so well designed |
Netscape tried to make it a server side language (LiveWire) instead of Perl but Java was much better here as well |
JavaScript lived on for simple arithmetic on client side to produce somewhat better frames (as clicking on a link can call a JavaScript function instead of just loading a URL) and to quickly check forms client side without going back to server which is slow |
A serious weakness was that dynamic aspects of JavaScript could only be used at "load" time and other changes of JavaScript required a "reload" which is real ugly and slow |
Then along came Microsoft and Netscape became distracted and quality of Java on the client side suffered and in fact is still problematical as Java in the browser has poor performance and lags Sun's version |
Further the Web Consortium W3C never really liked Java butting in and thought HTML was the answer |
JavaScript is Java with HTML and browser as AWT |
W3C came along with XML and the DOM (Document Object Model) |
In particular dynamic HTML extensions allowed one to get many benefits of JavaScript dynamically without reloading .... |
Now all this was screwed up in version 4 browsers -- especially by Netscape -- and so the vision was obscured! |
At least Microsoft's version 5 browser implements vision well |
So Java is a good low level tool and how you program your stock market simulation downloaded from the online broker |
However dynamical HTML and JavaScript is becoming preferred method of client implementations |
Use JavaScript to manipulate "components of documents" and Java to do arithmetic
|
As world develops HTML + JavaScript will become XML and HTML -- both with JavaScript to capture dynamic issues |
On Server, Java always wins (unless you use C++ for performance) |
Typically JavaScript is invoked from HTML and HTML text and JavaScript text are intertwined |
If you need to make a dynamic page from C++ Perl or Java you must write the HTML from these languages |
You can invoke applets from HTML but HTML and applet actions are not linked. In case of JavaScript HTML and JavaScript are closely linked |
JavaScript is an example of an important concept -- the domain specific interpreter which we can expect to be of growing importance
|
Text ...................................................... Computer Language HTML---> JavaScript Java <----- C++ |
ECMAScript refers to standard ECMA-262 released in June 1997 |
ECMAScript is essentially JavaScript with all client and server-side features removed i.e. It is the language and not the browser AWT handler |
The emerging HTML and XML Document Object Models (DOMs) are bound initially to ECMAScript |
So one can use ECMAScript in several different domains (HTML XML VRML ...) by adding support for appropriate domain specific objects |
Netscape Site has ECMAScript standard document |
Typically, up to 106 C instructions may be executed in a few milliseconds (the time it takes a person to notice anything!) as one instruction in 1 clock cycle (say 108/sec) |
A Java interpreter is roughly 50 times slower than C |
Java "Just-In-Time" compiler is roughly 2–8 times slower than C whereas a native Java Compiler (and perhaps future JIT's) are about same speed as C |
Perl is 500 times slower than C (an interpreter but analyses whole code before interpreting)
|
Tcl, JavaScript (true interpreters) are up to 5000 times slower than C
|
Web Page objects |
General Objects |
Pragmatic Object Web |
Multi Tier Object/Service Arch. |
HTML |
XML and XHTML |
XML as a Database Serialization |
JavaScript/ECMAScript |
Dynamic HTML DHTML |
CSS Cascading Style Sheets |
Document Object Model DOM |
Current DOM: JavaScript plus DHTML |
W3C DOM |
Jini and Service Architecture |
XML as Web Template Language |
CORBA and HPCC Examples |
CORBA and Security |
JWORB Pragmatic Object Web |
Gateway and XML |
Tango Architecture |
Collaborative or Shared Objects |
Universal Access |
Web-linked Databases |
Lotus Notes |
Shared Web Pages are Everything |
JavaScript Shared Browser |
DHTML = Dynamic HTML |
Capabilities of DHTML:
|
It is available now albeit in different versions for different browsers |
It is an extension of HTML and therefore familiar |
It addresses many of HTML's shortcomings |
It is focussed at "visual display" of a document and so is orthogonal to XML |
We can expect DHTML to change significantly in both implementation and syntax
|
3 Scenarios |
HTML4 |
HTML4 |
User Interacts |
with HTML Changing Dynamically Client Side (JavaScript catches mouse |
and keyboard |
events and |
interprets as |
changed DOM components: |
Browser |
renders) |
XML |
HTML4 |
Server with XML Parser |
XML |
Some XML and some |
HTML4 |
HTML4 or XML+HTML4 Browser |
DHTML consists of the following:
|
http://www.w3.org/Style/CSS/ is general link |
Cascading Style Sheets (CSS1) allow more precise and consistent layout than previous HTML attributes such as <FONT> |
Style sheets permit pages to inherit properties from other pages--in effect, they permit object-oriented document structure |
CSS2 was released in May 98, and includes support for media-specific style sheets (e.g. printers and aural devices), downloadable fonts, element positioning and tables.
|
CSS1 allows one to specify layout styles (size, color, position) and associate in flexible way with tags |
Flexible placement of style information -- either in sheets (i.e. separate pages), attributes (style="..") or style statements in header of HTML page |
Independence from specific scripting languages but natural link to JavaScript and works with XML and HTML |
Cascading style sheets i.e. one can have a hierarchy of style definitions from general to organization specific to user specific |
Example: A simple style sheet (in file "myStyle.css"): P.special { color: red; border: solid black; } |
Now put a <LINK> tag in the <HEAD> to be able to access information: <LINK href="myStyle.css" rel="stylesheet" type="text/css"> |
In the <BODY> tag, type: <P class="special">A special paragraph! |
<HTML> <HEAD> <TITLE>title</TITLE> |
<LINK REL=STYLESHEET TYPE="text/css" HREF="http://style.com/cool.css" TITLE="Cool"> |
<STYLE TYPE="text/css"> |
@import url(http://style.com/basic.css); |
H1 { color: blue } |
H2.vivid {color:pink} |
#myid {position:absolute; color:red; top:20; left:50; background-color:red; visibility:hidden} |
</STYLE></HEAD><BODY> |
<H1>Headline is blue</H1> |
<P STYLE="color: green">While the paragraph is green. |
<h2 class=vivid>And the secondary heading is Vivid</h2> |
<div id=myid> |
<h2>Default Color Positionable element</h2> |
</div> |
</BODY> </HTML> |
Selector |
Declaration |
Web Page objects |
General Objects |
Pragmatic Object Web |
Multi Tier Object/Service Arch. |
HTML |
XML and XHTML |
XML as a Database Serialization |
JavaScript/ECMAScript |
Dynamic HTML DHTML |
CSS Cascading Style Sheets |
Document Object Model DOM |
Current DOM: JavaScript plus DHTML |
W3C DOM |
Jini and Service Architecture |
XML as Web Template Language |
CORBA and HPCC Examples |
CORBA and Security |
JWORB Pragmatic Object Web |
Gateway and XML |
Tango Architecture |
Collaborative or Shared Objects |
Universal Access |
Web-linked Databases |
Lotus Notes |
Shared Web Pages are Everything |
JavaScript Shared Browser |
W3C DOM (http://www.w3.org/DOM/ ) defines a platform-independent programmatic interface to web documents:
|
Initially, DOM is bound to ECMAScript but is language neutral in design |
Current Browsers implicitly define a DOM which is somewhat different between Microsoft and Netscape and very different between versions 4 and 5 |
Here is an example of a particular source document encoded in HTML: |
<HTML> |
<TITLE>My home page</TITLE> |
<BODY> |
<H1>My home page</H1> |
<P>Welcome to my home page! Let me tell you about my favorite composers: |
<UL> |
<LI> Elvis Costello |
<LI> Johannes Brahms |
<LI> Georges Brassens |
</UL> |
</BODY> |
</HTML> |
Component Objects in Web Page |
Making dynamic pages with HTML and JavaScript requires two types of capabilities.
|
These capabilities EXIST in current browsers but are incomplete and different |
More powerful "standards" are part of W3C DOM1 and DOM2 and presumably these will be adopted |
In the meantime we adopt strategy which is supported by current browsers and can evolve to W3C DOM1,2 |
The first step is to define different named entities in document.
|
The position CSSP attribute takes values static (default) relative (position relative to where it "should be" in current "context") and absolute (position in current "context") |
These are properties of essentially ALL document components in the "DOM of our dreams" (this is what W3C defines)
|
<style type="text/css" > |
#WWmessage1 {position:absolute; color:black; visibility:visible; left:200; top:450; } |
</style> |
</head> |
<body onload="WW_pageisloaded();" > |
<h1>This is Page for CPS616 DHTML</h1> |
.... See page addon for full material (a form to specify layer properties) ..... |
<div id="WWmessage1" > |
This is a Moving Block of Text<br> |
Input (left,top etc.) and see! |
</div> |
Style |
Good Practice for all processing which requires that page elements be fully defined |
} |
A movable layer |
function WW_getlayer(idstring) { // Find layer with given label |
if( WW_Netscape4 ) { |
return eval("document." + idstring); } |
else { // Microsoft |
return eval("document.all." + idstring); } |
} // End WW_getlayer() |
function WW_layershiftto(obj,x,y) { // Move layer to given position |
if(WW_Netscape4 ) { |
obj.moveTo(x,y); } |
else { // Microsoft |
obj.style.pixelLeft = x; |
obj.style.pixelTop = y; } |
} // End WW_layershiftto(obj,x,y) |
WW_messageobject = WW_getlayer('WWmessage1'); |
WW_layershiftto(WW_messageobject,parseInt(x),parseInt(y)); |
id attribute in <div> #WWmessage1 in STYLE |
Returned by WW_getlayer |
Read in from form as text |
Decide on Browser |
function WW_pageisloaded() { // Initialize when page loaded |
if(WW_oldbrowser) |
return; |
if( WW_Netscape4 ) { // Netscape |
window.captureEvents(Event.CLICK); |
window.onclick=WW_processclick; } |
else { // Microsoft |
document.onclick=WW_processclick; } |
WW_pointerlayer = WW_getlayer('WWpointerblock'); // Pointer |
WW_pointerlayer.onmouseover = WW_overpointerblock; // Mouse Over |
WW_pointerlayer.onmouseout = WW_offpointerblock; // Mouse Out |
WW_pointermessageobject = WW_getlayer('WWpointermessage'); |
if(!WW_Netscape4 ) { // Microsoft set layer width |
WW_pointermessageobject.style.width =200; |
WW_pointerlayer.style.width=64; } |
return; |
} // End WW_pageisloaded() |
Capture ALL Click events and set handler |
Set event handlers for mouse events recognized |
in conventional way |
function WW_processclick(e) { // Process Mouse Click |
var clickX = WW_eventx(e); // Extract Mouse Click Position |
var clickY = WW_eventy(e); |
// Position Top right of pointer at mouse click |
var width = WW_getlayerwidth(WW_pointerlayer); |
WW_layershiftto(WW_pointerlayer,clickX-width,clickY); |
WW_layershow(WW_pointerlayer); // Make pointer visible |
WW_layertotop(WW_pointerlayer); // set zindex=1000 |
WW_offpointerblock(); // remove stray mouseover messages |
window.status = 'click'; // flag action |
// true implies that you continue conventional processing i.e. |
return true; // that clicks on links are recognized |
} // End WW_processclick(e) |
<student stdid="A1231999"> <name>Bugs</name> <surname>Bunny</surname>
|
</student> |
Web Page objects |
General Objects |
Pragmatic Object Web |
Multi Tier Object/Service Arch. |
HTML |
XML and XHTML |
XML as a Database Serialization |
JavaScript/ECMAScript |
Dynamic HTML DHTML |
CSS Cascading Style Sheets |
Document Object Model DOM |
Current DOM: JavaScript plus DHTML |
W3C DOM |
Jini and Service Architecture |
XML as Web Template Language |
CORBA and HPCC Examples |
CORBA and Security |
JWORB Pragmatic Object Web |
Gateway and XML |
Tango Architecture |
Collaborative or Shared Objects |
Universal Access |
Web-linked Databases |
Lotus Notes |
Shared Web Pages are Everything |
JavaScript Shared Browser |
http://www.sun.com/jini/ and also see very interesting Ninja project at UC Berkeley http://ninja.cs.berkeley.edu/ |
Jini is an innovative distributed computing capability that has features that
|
Jini enables services to be dynamically linked to users of services
|
Services can be printers, home stereo components, computers or pieces of software or .... |
All Jini federate members must support the Java VM or be represented by a proxy that does |
Jini has a classic 3 tier architecture with client, lookup service (called broker or server in other architectures) and service provider (the backend) |
There are four basic operations: Discovery, Join, Lookup, and Service Invocation |
Discovery Process: Service Provider broadcasts a request on network that all service providers identify themselves |
Lookup |
Service |
If device is not Java enabled, then a proxy can locate the lookup service on the device's behalf |
Finding one or more lookup services, the Service Provider loads its Java Interface and array of descriptive attributes into the Lookup Service |
Service Provider leases space in yellow pages of Lookup Service for a given time (Say one minute). Lease must be renewed before end of lease time else Lookup Services assumes service has been discontinued -- implements dynamic fault tolerant services |
Add |
Any client locates a Jini Lookup Service and hands a Service Template
|
Lookup Service provides a list of all Services matching this request and Client chooses appropriate service. |
Client downloads a Service object which can implement Service |
The downloaded Service Object implements Service |
Lookup Service no longer part of transaction |
This Service could be:
|
Note Client side Service Object came originally from Service Provider and so automatically consistent and up to date |
Service Object can be downloaded from central source by Service Provider to keep itself up to date |
Use of Lookup Service is typical yellow pages service in all distributed systems (cf. DNS etc.) |
Use of Java as IDL(Interface Definition Language) and RMI as transport layer is specific to Jini
|
Has a particular query syntax with attribute array and use of simple yes/no matching
|
Has a "leasing concept" which seems very valuable in distributed computing where resources are dynamic and fault tolerance important |
Web Page objects |
General Objects |
Pragmatic Object Web |
Multi Tier Object/Service Arch. |
HTML |
XML and XHTML |
XML as a Database Serialization |
JavaScript/ECMAScript |
Dynamic HTML DHTML |
CSS Cascading Style Sheets |
Document Object Model DOM |
Current DOM: JavaScript plus DHTML |
W3C DOM |
Jini and Service Architecture |
XML as Web Template Language |
CORBA and HPCC Examples |
CORBA and Security |
JWORB Pragmatic Object Web |
Gateway and XML |
Tango Architecture |
Collaborative or Shared Objects |
Universal Access |
Web-linked Databases |
Lotus Notes |
Shared Web Pages are Everything |
JavaScript Shared Browser |
Example comes from WebWisdomDB for storing training and education curricula objects -- PowerPoint, HTML, Photos .. |
XML embedded as part of HTML "Web Page" |
URL of Web Page invokes Servlet |
e.g. http://witch.npac.syr.edu/servlet/TDLServlet/witch/index.tdl?USID=67 |
Servlet leaves HTML untouched but calls Java Methods to process XML tags |
This Servlet processes <WW_... tags -- others are left for other servers or browser |
Educational Objects i.e. |
Data Defining Curricula Material at all levels from "University" to "foil" |
Server side |
Java(JDBC) |
XML Parser |
Servlet |
Metadata |
WebWisdom XML Template Server |
Conventional XML/HTML Pages |
Dynamically Generated |
(IMS/ADL) Metadata |
Streaming Audio/Video |
Cross Disability Shared Choice of CSS |
Templates Defining in XML How educational data stored in Pages |
Share with TangoInteractive |
JavaScript API |
<!-- WW_CONNECT is a tag that establishes a connection to the database. Connection string may be supplied in the CONNECTION attribute, or if it is omitted (empty string) the default connection string is taken from properties.txt file for current template.--> |
<WW_CONNECT CONNECTION=""/> |
<html> <head> <title> Separate IMAGE for LOCAL foil |
<!-- WW_FOILNUMBER tag takes the position of the current foil in the current presentation. --> |
<WW_FOILNUMBER PARENTID="${PID}" FOILID="${FID}"/> |
<!-- WW_TITLE is a tag that allows to insert title of a presentation or foil. The presentation/foil is identified by an ID supplied in FOILID attribute. PARENTID is not currently used by the WW_TITLE tag, but can be later used, e.g. to check the formatting properties, which can be defined on the presentation level. FID and PID were supplied by the servlet from query attributes of the URL --> |
Yellow is ordinary HTML, Green XML, White Comments |
<WW_TITLE FOILID="${FID}"/> |
</title> </head> |
<!-- WW_BODYIMAGE inserts a 'body' HTML tag with background image typical for foil files. --> |
<WW_BODYIMAGE/> |
<tt><a href="#image">Image</a><a href="#buttons"> Buttons</a> </tt> <b> |
<WW_LINK FILENAME="temphelp.tdl" ATTR="">HELP!</WW_LINK> * GREY=local</b><tt> LOCAL IMAGE version of Foils prepared |
<!-- WW_MODIFICATIONDATE inserts modification date of the current foil --> |
<WW_MODIFICATIONDATE FOILID="${FID}"/> </tt> |
...... And So On! |
Web Page objects |
General Objects |
Pragmatic Object Web |
Multi Tier Object/Service Arch. |
HTML |
XML and XHTML |
XML as a Database Serialization |
JavaScript/ECMAScript |
Dynamic HTML DHTML |
CSS Cascading Style Sheets |
Document Object Model DOM |
Current DOM: JavaScript plus DHTML |
W3C DOM |
Jini and Service Architecture |
XML as Web Template Language |
CORBA and HPCC Examples |
CORBA and Security |
JWORB Pragmatic Object Web |
Gateway and XML |
Tango Architecture |
Collaborative or Shared Objects |
Universal Access |
Web-linked Databases |
Lotus Notes |
Shared Web Pages are Everything |
JavaScript Shared Browser |
Navigate and choose an existing application to solve the problem at hand. Import all necessary data. |
Retrieve data |
Pre/post-processing |
Run simulations |
Select host |
Select model |
Set parameters |
Run |
Globus High Performance Backend |
Java Applet Frontend |
Java Servers in Middle Tier |
Database Service |
Computing Service Providers |
Visualization |
IIOP |
/RMI |
Invoke Composition Service |
CORBA has many services defined |
Object Management Group has just requested that distributed and parallel computing services be defined |
SECIOP |
Front End Applet |
https |
authentication |
& authorization |
Gatekeeper |
delegation |
Stakeholders |
HPCC resources |
GSSAPI |
GSSAPI |
Layer 1: secure Web |
Layer 2: secure CORBA |
Layer 3: Secure access to resources |
Policies defined by resource owners |
https (SSL) |
AKENTI |
CORBA security service |
GSSAPI (Globus) |
Mary Thompson, http://www-itg.lbl.gov/security/Akenti/DOE2000/sld014.htm |
JWORB - Java Web Object Request Broker - multi-protocol middleware network server (HTTP + IIOP + DCE RPC + RMI transport) |
Current prototype integrates HTTP and IIOP i.e. acts as Web Server and CORBA Broker
|
Currently testing support of Microsoft COM |
JWORB - our trial implementation of Pragmatic Object Web |
First non DMSO implementation of RTI -- HLA (distributed event driven simulation) Runtime at 5% cost(!) |
DoD Modernization Project at ASC Dayton |
Client Tier is set of XML Templates and Java front ends
|
Middle Tier is Object Broker
|
Back-end Tier using Globus Toolkit and classic HPCC
|
XML Templates that you can customize for each domain -- Chemistry is first example |
Some "general XML Buttons such as <visualize render="AVS">See it!</visualize> invokes middle-ware visualization service and AVS renderer |
Others such <gaussian version="1.37"> <basisfunction> ... are domain specific |
Ken Flurchick, http://www.osc.edu/~kenf/Gateway |
Web Page objects |
General Objects |
Pragmatic Object Web |
Multi Tier Object/Service Arch. |
HTML |
XML and XHTML |
XML as a Database Serialization |
JavaScript/ECMAScript |
Dynamic HTML DHTML |
CSS Cascading Style Sheets |
Document Object Model DOM |
Current DOM: JavaScript plus DHTML |
W3C DOM |
Jini and Service Architecture |
XML as Web Template Language |
CORBA and HPCC Examples |
CORBA and Security |
JWORB Pragmatic Object Web |
Gateway and XML |
Tango Architecture |
Collaborative or Shared Objects |
Universal Access |
Web-linked Databases |
Lotus Notes |
Shared Web Pages are Everything |
JavaScript Shared Browser |
NPAC Web Server |
JSU Web Server |
Java Tango Server |
....... |
Share URL's |
Audio Video |
Conferencing Chat Rooms |
White Boards etc. |
Address at JSU of Curriculum Page |
Teacher's View of Curriculum Page |
Student's View of Curriculum Page |
Participants at JSU |
Teacher/Lecturer at NPAC |
....... |
Java Socket |
HTTP |
Java Control Clients |
Some sort of activity involves interactions between objects and/or objects and individuals (which can be thought of as objects as well if you want) |
Interaction can be synchronous as when individuals talk to each other; parallel program components exchange MPI messages
|
Or asynchronous when sharing is done at different times |
I post a web page and you look at it later is basic asynchronous sharing model while writing on a blackboard is hallowed synchronous model in teaching
|
This implies choosing a rendering method that best suits client user and respects
|
e.g. Visually impaired would prefer audio rich rendering |
e.g. Muscularly limited users would need appropriate interfaces |
New Cascading Style Sheets can express this but need intelligent renderer to make correct decision and allow user to adjust choices |
Further one needs decision at the stage of XML input and not after it has already been rendered into HTML
|
Assume goal is equal and high quality rendering -- do not downgrade material to support cross disability rendering |
Assume teachers, students, engineers, shoppers, salespersons, families teach, learn, collaborate, buy, sell, socialize via electronic versions of traditional human interactions combined with shared objects rendered as web pages
|
One needs to be able to
|
So web documents are the natural choice but actually this doesn't say so much as they can have
|
And "everything" exports itself to the web including Microsoft Word and Macromedia authoring systems
|
So we will consider first Web documents constructed according to W3C DOM |
Well there is the battles between Sun Netscape and Microsoft which makes Java on the client less robust than Java on the server |
However Java allows to build totally general users interfaces and there appear to be no rules. |
Thus it does not seem practical to build cross disability interfaces for arbitrary Java applet interfaces |
On the other JavaScript and dynamic HTML can do many things that you might have thought one needed Java for |
General Java visual interfaces need languages such as UML to describe interface object model? |
Web-linked databases look "just" like web pages and in fact using XML templates one can store DOM components in database and improve representation of object structure of pages
|
On the other hand, current Lotus Notes supports a web client but does not naturally integrate with other web resources
|
One needs to certainly share the basic page URL but also
|
JavaScript in principle allows one to identify relevant DOM components , change the rendering through choice of style attached to each component and so deliver a cross disability shared rendering |
Shared Pointer added to Internet Assistant PowerPoint on the Web |
Movement tracked and shared with JavaScript |
Illustrates sharing of W3C Object Model internal to documents |
DHTML "Heartbeat" recording shared events in last 60 seconds on application specific "bar" which is locked above all windows -- addresses window clutter |
Shared Multiple List |
Shared Buttons |
Shared Text field |
Shared Checkbox |