INTEROP-1.1 CSE298 CSE300 CSE333 Interoperability Strategies for Enterprise Computing Prof. Steven A. Demurjian Computer Science & Engineering Department The University of Connecticut 191 Auditorium Road, Box U-155 Storrs, CT 06269-3155 [email protected]http://www.engr.uconn.edu/ ~steve (860) 486 - 4818
34
Embed
Interoperability Strategies for Enterprise Computing
Interoperability Strategies for Enterprise Computing. Prof. Steven A. Demurjian Computer Science & Engineering Department The University of Connecticut 191 Auditorium Road, Box U-155 Storrs, CT 06269-3155. [email protected] http://www.engr.uconn.edu/~steve (860) 486 - 4818. - PowerPoint PPT Presentation
Welcome message from author
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
INTEROP-1.1
CSE298
CSE300
CSE333
Interoperability Strategies for Enterprise Computing
Prof. Steven A. Demurjian
Computer Science & Engineering DepartmentThe University of Connecticut
Architectural Alternatives and FrameworksArchitectural Alternatives and Frameworks Taxonomy of Architectural Variants Integration via Java, CORBA, etc.
Case Study: The ADAM EnvironmentCase Study: The ADAM Environment Upgrading a C++ Legacy Application to be
Java-Compatible The TwinPeaks Software Package Pros and Cons of Effort
Issues for InteroperabilityIssues for Interoperability Concluding Remarks and DiscussionConcluding Remarks and Discussion
Java is Medium of Info. Exchange - C/C++ Appls with Java Wrappers
INTEROP-1.8
CSE298
CSE300
CSE333
ADAM: User PerspectiveADAM: User Perspective
ServerAbstraction for Design Persistence
C++Ada83, Ada95EiffelJava (on PC/NT)Ascii/Latex Doc.
Ontos OODBS
Multiple Versions: ADAM/Unix: IV3.1, X, Sparcstation ADAM/PC: Win95, Borland C++ ADAM/NT: Under Development
Code/Documentation Generation
ADAM GraphicalUser Interface
OODesign
INTEROP-1.9
CSE298
CSE300
CSE333
Case Study: The ADAM EnvironmentCase Study: The ADAM Environment
ADAM is a C++ Legacy Application with: ADAM is a C++ Legacy Application with: GUI Interviews/Unidraw Core C++ Internal Classes which are Compiler
Independent Designs Stored in Ontos OODBS
Redesign/Reformulate ADAM as:Redesign/Reformulate ADAM as: Java Client that Replaces C++ GUI Java Server Wraps Core C++ Internal Classes C/S Communications via Java Designs Stored in Jasmine (1998 Task)
Similar to Providing C/S Interactions for an C++ Similar to Providing C/S Interactions for an C++ Legacy/COTS ApplicationLegacy/COTS Application
INTEROP-1.10
CSE298
CSE300
CSE333
Characterizing ADAM Software ProfileCharacterizing ADAM Software Profile
C++ Class Library - Intended as a Single-CPU, C++ Class Library - Intended as a Single-CPU, Single-User, Interactive Design EnvironmentSingle-User, Interactive Design Environment
C++ Classes Structured as Multiple Interacting C++ Classes Structured as Multiple Interacting Hierarchies for Different Components:Hierarchies for Different Components: C++ Classes for GUI C++ Classes to Store Design as it is Created C++ Classes for Code Generation Capabilities C++/Ontos Classes for Persistence
Source Code Level Access to ADAM SoftwareSource Code Level Access to ADAM Software Goal: Minimize Code-Level Modifications as Goal: Minimize Code-Level Modifications as
ADAM Moves to Java Client/Server ParadigmADAM Moves to Java Client/Server Paradigm
INTEROP-1.11
CSE298
CSE300
CSE333
ADAM: Current Software ArchitectureADAM: Current Software Architecture
C++ Classes/Instancesto Store Design and
Code GenerationAlgorithms
DB ServerAbstraction for Design Persistence
C++Ontos C++Ada83, Ada95EiffelJava (on PC)
Ontos OODBS
ADAM/Unix: IV3.1, X, SparcstationADAM/PC: Win95, Borland C++
Design/GenerationCompiler Independent Software
ADAM GraphicalUser Interface
OODesign
INTEROP-1.12
CSE298
CSE300
CSE333
Client Requirements and FunctionalitiesClient Requirements and Functionalities
New ADAM Java Client Replicates Core C++ New ADAM Java Client Replicates Core C++ Classes to Allow Transitory Storage of Designs: Classes to Allow Transitory Storage of Designs: Existing Designs from Legacy Server Storable
at ADAM Java Client New/Existing Designs at Java Client Locally
Manipulated to Reduce Communication Traffic New/Existing Designs Sent to Legacy Server
for Persistent Storage Java Communications from Client to ServerJava Communications from Client to Server
Transmission of Modified Design to Server Receipt of Existing Design from Server Both Accomplished via Object Serialization
INTEROP-1.13
CSE298
CSE300
CSE333
Client Requirements and FunctionalitiesClient Requirements and Functionalities
ADAM C++Legacy Application
(Server)
Java/TwinPeaksWrapper
Existing Designs Sent/Loaded for Local Manipulation
Wrapper Requirements and FunctionalitiesWrapper Requirements and Functionalities
Transmission/Receipt of Messages from ClientsTransmission/Receipt of Messages from Clients Existing Design from Server to ClientExisting Design from Server to Client
Locating C++ Instances in Legacy Server Creation of Java Instances from C++ Instances Object Serialization of Java Instances to Client
Store New/Existing Design from Client to ServerStore New/Existing Design from Client to Server Receipt of Java Instances via O-Serialization Creation of C++ Instances from Java Instances Storage of C++ Instances into Legacy Server
Interactions between Java and C++ via Java Native Interactions between Java and C++ via Java Native Interface (JNI) or TwinPeaksInterface (JNI) or TwinPeaks
ADAM: Java to C++ WrapperADAM: Java to C++ Wrapper
Com
mu
nic
atio
n
Java Design Classes
and Instances
Tra
nsl
atio
nJa
va t
o C
++
Lib
rary
Fol
der C
lass Fold
er
C+
+ C
omm
on In
terfaceADAM
C++ Legacy Classes
and Instances
TwinPeaks
Legacy Application Wrapper
INTEROP-1.18
CSE298
CSE300
CSE333
Communication Requirements and Communication Requirements and FunctionalitiesFunctionalities
Layers of Classes/Instances (Client vs. Server)Layers of Classes/Instances (Client vs. Server) Interface (GUI) Classes and Instances (C) Java Design Classes and Instances (C&S) Java Communication Classes and Instances
(C&S) Translation Java to C++ Classes and Instances
(S) Communications Communications
Sockets (Current) Object Serialization (Current) CORBA/ORBs vs. RMI (Future)
Potential Performance Issue: Multiple Layers of Translation
CO
MM
UN
ICA
TIO
NC
OM
MU
NIC
AT
ION
CO
MM
UN
ICA
TIO
NC
OM
MU
NIC
AT
ION
Java
Com
mu
nic
atio
nC
lass
es/I
nst
ance
sJava C
omm
un
icationC
lasses/Instan
ces
Java
Des
ign
Cla
sses
/In
stan
ces
Java Client
GUIClasses
and Instances
Java Design
Classes/In
stances
Java Wrapper
TranslationJava to C++
LegacyCode
AdamC++
Server
INTEROP-1.20
CSE298
CSE300
CSE333
TwinPeaks Requirements and TwinPeaks Requirements and FunctionalitiesFunctionalities
Evaluated Feasibility of JNI Evaluated Feasibility of JNI Directly Access Native Layer Eliminates Platform Independence Difficult to Understand and Use
Exploring TwinPeaks ProductExploring TwinPeaks Product Beta Product from Sun Automatically Generates Java Interface to C or
C++ Native Library Analyzes Native Library Header Files to
Produce a Java API that Closely Mirrors Original C/C++ API
Status of TwinPeaks EffortStatus of TwinPeaks Effort
Established TwinPeaks EnvironmentEstablished TwinPeaks Environment Downloaded Multiple Times due to Difficulty
in Setting up Software and Multiple Releases by SunSoft
Worked to Understand the Mechanism and Proper steps Needed to work with TwinPeaks
UConn Beta Testing Site of Product: UConn Beta Testing Site of Product: Initial Efforts in Sept and Oct 97 Provided
Feedback and Suggestions to SunSoft Many of Suggestions for Improvement
Reflected in the Second Release
INTEROP-1.23
CSE298
CSE300
CSE333
Status of TwinPeaks EffortStatus of TwinPeaks Effort
As of January 15, 1998As of January 15, 1998 Installed Newest TwinPeaks Release Developed Two Test Prototypes that Generates
the Java to C++ Mapping for Subset of the ADAM C++ Server Legacy Code
Written a Detailed Report Describing this Effort Written a Detailed Report Describing this Effort that will be Critical in Continuing this Workthat will be Critical in Continuing this Work
The Java/C++ Interface is Pivotal for Integrating The Java/C++ Interface is Pivotal for Integrating and Upgrading Legacy Software to Java and Upgrading Legacy Software to Java
INTEROP-1.24
CSE298
CSE300
CSE333
Assessment of TwinPeaks ProductAssessment of TwinPeaks Product
PROsPROs To Our Knowledge, the Only Available Tool
that Supports Java to C/C++ at High Abstract. Automates Tedious/Error Prone Process an of
Generating Peer Java classes for C++ Code Offers Clever Techniques to Solve Mismatch
Between Java and C/C++ Pointers Multiple Inheritance Operator Overloading
Cost - Currently TwinPeaks is Free!
INTEROP-1.25
CSE298
CSE300
CSE333
Assessment of TwinPeaks ProductAssessment of TwinPeaks Product
CONSCONS Supports Very Limited Platform
Solais and SunSoft C++ What about Windows 95, NT, and Linux Apps?
Based on Native Method Specification and not Up-to-Date JNI
Potential for Incompatibility and/or Abandonment in Future
Automatic, but Difficult to Use Very Limited Support/Documentation
Minimal Small User Community
INTEROP-1.26
CSE298
CSE300
CSE333
Assessment of TwinPeaks ProductAssessment of TwinPeaks Product
CONsCONs Requires Familiarity with SunSoft C++ and Java
Native Method No Debugging Facilities Makes Understanding
and Correcting Errors Difficult Generics, Unions, and other C/C++ Features not
Supported No support for calling Java from C++
Conclusion: Conclusion: TwinPeaks is not a Stable Tool Falls Short of our Expectations Acceptance/Adoption for EC Applications is
C++ Legacy Applications Upgrade to C/S C++ Legacy Applications Upgrade to C/S Architectural Solution with Java Requires:Architectural Solution with Java Requires: Ability to Pull-Off or Disable Legacy GUI
Needed to Support Wrapping Process May Not be Possible for Every Legacy/COTS
application Source-Code Availability or Robust
Programming Interface Alternative to Disable A Robust OO API Assist Wrapper Creation and
C++ Legacy Applications Upgrade to C/S C++ Legacy Applications Upgrade to C/S Architectural Solution with Java Requires:Architectural Solution with Java Requires: Development of a New Java GUI/Client
New GUI to Collect, Synthesize, Interpret Information from Multiple Legacy/COTS
New/Innovative Uses for Legacy/COTS Applications
Short-Term Persistence of Client Data Thin vs. Medium vs. Thick Clients For EC Applications, if Clients Leave Network,
Local Storage is Needed Must Also Consider Limited Bandwidth
C++ Legacy Applications Upgrade to C/S C++ Legacy Applications Upgrade to C/S Architectural Solution with Java Requires:Architectural Solution with Java Requires: Message Passing Interface to Legacy Appl.
If Not Present, Embed in Communications Layer of both Client and Wrapper
For EC Applications, Extra Layers May be Required to Transform Legacy Data to OO/Java
Integration of Java and C++ Java Wrapper Requires Bi-Directional Exchange
of Information to/from C++ Automated Tools (TwinPeaks) vs. JNI For EC Applications - C, C++, Ada, Fortran, etc.
Utilization of our Efforts on ADAM as BlueprintUtilization of our Efforts on ADAM as Blueprint C++ Legacy Application (with/out GUI) Source Code Availability/Programming Interf. New Java Client Appls/Java Server Wrapper Message Passing Interface Redesign/Development of Java Client Classes
that Mirror/Imitate Legacy Server Classes Introduction of Multiple Layers of Translation Increased Overhead with Java or CORBA Applicability to Well-Designed C Appls
Conclusion: Significant Effort with Potential Conclusion: Significant Effort with Potential Long-Range Benefit of Common Java MediumLong-Range Benefit of Common Java Medium
PROsPROs Likely Applicable to C and C++ Component-Based, Organized Approach Greatly Facilitates Exchange of Information Solves the N x M Translation Problem
CONsCONs Additional Overhead Due to Translations Instability/Immaturity of TwinPeaks Complexity and Effort of Task Performance Degradation Unacceptable
Conclusion: Do Java, CORBA, etc., Benefits Conclusion: Do Java, CORBA, etc., Benefits Outweigh the Risks and Shortfalls?Outweigh the Risks and Shortfalls?
INTEROP-1.33
CSE298
CSE300
CSE333
Concluding Remarks and DiscussionConcluding Remarks and Discussion
What are Keys Issues that Influence and Guide the What are Keys Issues that Influence and Guide the Integration Process for EC?Integration Process for EC? Software Reuse in a Distributed Computing
Environment Reuse Existing Legacy/COTS in Innovative Ways Not Cost Effective to Redesign/Reimplement EC Users will Demand Modern Interfaces on Up-
to-Date Platforms Wrappers for Cohesive/Seamless Interactions
Apply to Languages (C, C++, Ada, etc.) and Paradigms (OODBS, CORBA, RPC)
Address Communication, Translation, Security, Concurrency, Performance, Bandwidth, etc.
INTEROP-1.34
CSE298
CSE300
CSE333
Concluding Remarks and DiscussionConcluding Remarks and Discussion
What are Keys Issues that Influence and Guide the What are Keys Issues that Influence and Guide the Integration Process for EC?Integration Process for EC? Communications Alternatives Dictated by
Application Domain Tradeoffs of Low-Level (Sockets) vs. Mid-Level
(RCP, RMI) vs. High-Level (CORBA, DCOM, …) Will EC Utilize Combination?
Consistency of Information in Distributed Computing Environment When is Data Sent from Client to Legacy Server? Automatic (Regular) vs. User-Initiated? When Network Traffic is Low? EC Likely Spans Broad Spectrum