%in kaalfontein+277-882-255-28 abortion pills for sale in kaalfontein
A Natural Web Front End using CICS Transaction Gateway
1. 11/19/15
A Natural Web Front End using
CICS Transaction Gateway
Michael Erichsen, CSC
GSE Nordic and UK CICS Conference
Hursley, May 1999
Session N25
2. 11/19/15
Agenda
CSC
Covering Students’ Living Costs
The US2000 Project
A three Tier Architecture
Three different views of Data
The Program Flow
Java Development
Other Challenges
3. 11/19/15
CSC
A “Collection of Small Companies” - 51,000 employees
Management Consulting
Systems Integration & IT Consulting
Technology Management
CSC Scandinavia
CSC Denmark
CSC Computer Management
CSC Sweden
5. 11/19/15
Covering Students’ Living Costs
SU (Statens Uddannelsesstøtte) is the Danish State
Education Grants and Loan Scheme Agency
Provides for 250,000 students every year
Tuition is free at public and most private educational
institutions
Supports students with grants and loans
Annual budget over 8,000,000,000 DKK - 0.6% of GNP
7. 11/19/15
The US2000 Project
The current system consists of 70+ 3270 applications
running Software AG Natural and Adabas on CICS/VSE
The Agency decided in 1997 to modernise system
Asked three partners for proposals November 1997
A technical model was prepared by CSC in May 1998
Specification made in June 1998
CSC on project July 1998
Pilot production 2Q 1999
Full implementation 4Q 1999
8. 11/19/15
Why a Web Interface?
A modern graphical user interface
Safeguard the investment in business logic
Maintain a stable environment
Easier to learn for new users
Can cooperate with PC environment
Relieve the Agency of the responsibility for the users’
network connections and software distribution
Enabling self service by students
10. 11/19/15
PC UNIX Server VSE
WEB
Browser
CICS Client
CICS
Gateway
for Java
WEB Server
VTAM
CICS
Natural
HTTP
APPC
ADABAS
Personal
Comm
A Three Tier Architecture
11. 11/19/15
The Communication Architecture
A classic Windows Client/server model was rejected due
to configuration and software distribution problems
A general transaction format is designed to simplify
programming
Application logic in Client and on CICS/VSE, not on
middle tier
Fundamentally just a new incarnation of the well-tested,
rock-solid transaction processing model
12. 11/19/15
Why a Middle Tier?
CICS/VSE has no direct Web interface - yet
Design prepared for interfacing directly with CICS
Two different proposals:
SAG Entire Broker
CICS Transaction Gateway
The Agency bought a complete IBM package with
RS/6000, AIX, LDGWS, and CICS Transaction Gateway
for the middle tier
13. 11/19/15
The Server Architecture
Total separation of user dialogue from business logic
and data access
Natural programmers can concentrate on business logic
Willing to reprogram 3270 applications to server
programs
Prepare architecture for the future
Two simple CICS Assembler programs make up server
end of "Pipeline"
15. 11/19/15
The Client Architecture
Visual classes
Formatting classes
Transaction classes
The architecture has matured through three steps to
Client heaven
Step 1: The decision to use Java
Step 2: Applets or Applications
Step 3: Java Beans
16. 11/19/15
Step 1: The Decision to use Java
Better function than plain HTML
Enables mouseless operation
Java Applets are easy to distribute on-line
Response time proves acceptable
Averaging 0.5 seconds on browser
17. 11/19/15
Step 2: Applets or Applications
Applications run Stand-alone on the desktop
Applets run inside a browser
Problems with caching of jar files
Browsers are not compatible
Applications can also be distributed on-line
But loses some functionality
18. 11/19/15
Step 3: Java Beans
Java Beans is a component technology
Helps to design for code reuse
Visual builder tools understands the components
Systems programmers can encapsulate complexities
and validation in Java Beans
Application programmers can concentrate on user
interfaces
Both applets and applications can be built from Java
Beans
20. 11/19/15
Three Different Views of Data
Java classes
Internal fields/properties with names and types
Accessed through "setter" and "getter" methods
CICS Program
One long buffer (Commarea) with an implicit structure
Each end must understand offsets, lengths and types
Natural Programs
Positional parameters with names and types
Accessed by name
21. 11/19/15
How to Map a Commarea?
Different models
Self describing format
Variable length fields
Predefined structure known by both ends
...
Characters only or binary numeric data?
22. 11/19/15
Predefined Transaction Format
SSeeggmmeenntt UUsseedd bbyy CCoonntteennttss
A Pipeline only Password
Natural and
Adabas identifiers
Internal response
time
B Pipeline
Natural Control
Userid
Error information
C Natural Control
Server Programs
Personal ID No.
Response text
Journal
information
D Specific Server
Program only
Transaction
specific fields
23. 11/19/15
Data Inversions
SSuubbssyysstteemm DDaattaa vviieewweedd aass DDaattaa aacccceesssseedd bbyy
Client front-end Visual fields Getters and
setters
Client back-end Bean Properties Getters and
setters
Pipeline Data buffer -
Natural programs Positional
parameters
Name
27. 11/19/15
Formatting Beans
A M O U N T _ N 8
B e a n
D D _ M M _ Y Y Y Y
B e a n
C P R N R
B e a n
E t c .
N a t u r a lF o r m a t e r in g
( A b s t r a c t )
C o m p o n e n t
O b je c t
28. 11/19/15
Transaction Beans
D is p la y S t u d e n t I n fo r m a t io n
B e a n
D is p la y P a r e n t I n c o m e
B e a n
E t c .
C s c A b s t r a c t T r a n s a c t io n
O b je c t
31. 11/19/15
3GL Front End on CICS
Distributed Program Link with a Commarea from CICS
Client through APPC
Saves Commarea in a Temporary Storage queue
Saves User id, response time etc. in a Data Table for
surveillance and performance monitoring
Links to Natural Boot Strap with a list of dynamic
parameters including data from the A and B segments
32. 11/19/15
Natural Boot Strap Program
Does Natural initialisation and housekeeping behind the
covers
Cannot be called with data
Calls out again to another 3GL program
Just two lines of code
33. 11/19/15
3GL Back End on CICS
Reads the Commarea from Temporary Storage
Allocates extra storage for communication between
Natural subprograms to prevent storage violations
Calls Natural Parameter List Builder Program
Calls Natural Control Subprogram with Commarea as a
single positional parameter
Afterwards data is returned through Temporary Storage
A dummy back end seems to be necessary to get
around Natural’s Menu system...
34. 11/19/15
Natural Subprograms
Natural Control Subprogram
Subdivides the Commarea into positional parameters
Gives control to the appropriate server subprogram
Saves response time returned from the Client
Assembles data from server subprogram back into a single
positional parameter
Natural Server Subprogram
Validates data
Does business logic
Accesses Adabas
Eventually about 100 server programs with as many
different D segments
37. 11/19/15
Java Development
Objects, reuse, and components
Division of work
Education
Designing the component architecture
Visual builder tools and how to choose them
38. 11/19/15
Objects, Reuse, and Components
Object technology still hasn’t fulfilled the promises of
code reuse
Have to consciously build code reuse into the design of
classes and applications
Components can help doing this
Supported by a new generation visual builders
Need to organise the project group division of work
Need to adopt an iterative development process
39. 11/19/15
Division of Work
Visual application programmers
User interface
Systems programmers
Communication
Complex technical matters
Tools for each kind of person
Optimal use of differentiated qualifications and interests
Make it fun for everybody to ensure motivation and to
reduce staff turnover
41. 11/19/15
Education
Java is difficult to learn for a Natural or 3GL developer
Objects is a different ballgame than structured (or even
unstructured) programming
Components are something else again
Three distinct education needs
User interface design
Object design
Using the specific tool
42. 11/19/15
Designing the Component Architecture
Generalise common functionality into abstract parent
classes
Secures optimal reuse of code
Concrete, derived classes only contain what is specific to
them
An iterative development process
Continuous identification of functions to be moved from
application to systems programming
Keep classes small and simple
43. 11/19/15
Visual Builder Tools
Visual Café from Symantec
Visual Age from IBM
More than 20 others
Started with Visual Café 2.5
Changed to Visual Age 2.0
44. 11/19/15
Criteria for Visual Builder Choice
Import/export of source
Support for the preferred division of work
Support for programming styles and services
External support
46. 11/19/15
Natural in - Java out
16:23:44 Subprogram ISTA Library U
0010 ************************************
0020 * PROGRAM : ISTA
0030 * FUNKTION : Stamoplysninger
0040 * BESKRIVELSE : Viser stamoplysnin
0050 * støtteår.
0060 * Programmør : Finn Jørgensen
0070 * OPRETTET : 16-12-1998
0080 ************************************
0090 * Versionsændringer:
0100 *
0110 * Version Init Dato Beskrivelse
0120 * ------- ---- -------- ------------
0130 * 001 FJ 16-12-98 VERSION 1.
0140 ************************************
0150 DEFINE DATA PARAMETER
0160 *
0170 USING A-PARMTR
0180 *
0190 LOCAL USING T-PERSON
0200 LOCAL USING T-REKVIS
0210 *
package dk.su.us2000.trans;
import java.beans.*;
import com.sun.java.swing.*;
/*** This class represents the commarea b
* It is generated by the CSC Commarea Ge
* <p>This class contains accessors and m
* in the D segment of the transaction de
* It inherits accessors and mutators
* for the A, B, and C segments from its
* @version Natural: 981216 16:23, Java:
* @author Finn Jørgensen
*/
public class ISTA extends dk.su.us2000.tr
/** No-arg constructor
*/
public ISTA() {
super();
initialize();
} // No-arg c:tor
/** Gets the VERSION property (String) va
* @return The VERSION field.
* @see #setVERSION
*/
public String getVERSION() {
byte[] ba = new byte[3];
System.arraycopy(commarea, 830, ba, 0, 3)
String sout = new String(ba);
if (isDebug()) {
System.out.println("Method getVERS
} // if debug
return strip(sout, "N");
} // getVERSION()
49. 11/19/15
State Handling
CICS pseudo transactions have states - web
transactions are stateless
User can go away without telling CICS
Retaining sign-on between calls
Achieving update integrity by serialisation using
timestamps on each database record
50. 11/19/15
New Version Problems on Old Bottles
Web distribution solves the old version problems
But the most common browsers do not implement Java
identically
Can be remedied by using the Java Plug-In
Still have to handle a multitude of version
interdependencies and incompatibilities
51. 11/19/15
Security
Logon is done with userid and password and is
validated by Natural Security
A user profile is retrieved from Adabas and sent to the
Client to control the dynamic menu
Security of userids, passwords, and data when running
on the open network is currently being analysed
CSC has operated in Europe since 1966 with HQ in Farnborough, England.
The specific industries for which we currently provide experience and expertise in Europe include Chemicals, Financial Services, Government, Healthcare, Information Technology, Life Sciences, Manufacturing (Aerospace, Automotive, Discrete), Oil and Gas, Retail, Telecommunications and Travel and Transport.
In Europe we are 15,000 employees in &gt;200 locations in 16 countries.
Number of employees and locations in the Nordic Area:
Norway 100 1
Sweden 100 1
Denmark1,200 5
CSC Denmark: Development & Consultancy
CSC Computer Management: Facility Management, Data Centre Operations & Network Services
CSC Sweden: Consultancy
CSC Norway: Financial and Insurance Applications
SU (Statens Uddannelsesstøtte) is the Danish State Education Grants and Loan Scheme Agency
Under the auspices of the Danish Ministry of Education
Provides for 250,000 students every year
Tuition is free at public and most private educational institutions
SU supports students aged 18 and above with grants (6,600,000,000) and loans (1,400,000,000)
Loans are paid back after graduation (or giving up studies)
Annual budget over 8,000,000,000 DKK - 0.6% of GNP
Combine a modern graphical user interface with the investment in business logic and a stable development and operations environment
Willing to re-code the back end into server programs while retaining the business logic
3270 to be phased out completely
Easier to learn for new users
Cooperate with PC environment
Relieve the Agency of the responsibility for the users’ network connections and software distribution
Initially 500 existing 3270 users in educational institutions
Enabling self service by students
When the architecture was designed, CICS Gateway for Java and the CICS Client were bundled, but separate components.
They have now been merged into the CICS Transaction Gateway and the CICS Client has been promoted to a CICS Universal Client
CICS/VSE has no direct Web interface - yet
Design prepared for interfacing directly with CICS
Will only need to change a single abstract class
Two different proposals:
SAG Entire Broker
Deemed too complicated to program
Unstable on VSE
CICS Client + CICS Gateway for Java = CICS Transaction Gateway
Fits together with CICS/VSE, but not with Natural
Willing to reprogram 3270 applications to server programs
Replace SEND/RECEIVE MAP with LINK PROGRAM COMMAREA
Prepare architecture for future availability of CICS Web Interface on VSE
Also for other types of communication like FTP of batch input from other systems at large educational institutions
If you find this slide ugly, you should try to read the manual!
Natural is born to send and receive 3270 24*80 characters screens
Natural subprograms can be called from a 3GL through the “NATCALL” interface with a standard parameter list
Rather vaguely documented in Natural manuals
Had to do some guessing and some disassembly to understand why samples had to be followed 100%
One circumvention did not survive upgrading Natural from V228 to V232
Follows quite a wrinkled path into Natural
Three front-end and one back-end program needed
Visual classes
Present the user interface
Formatting classes
Handle validation
Transaction classes
Make up client end of &quot;pipeline”
Browsers are not compatible
Applets might look different from how you want them to
Applets might not run at all
Applications can also be distributed on-line
Users must accept to click on a “Download” button on your home page and an “Install” button afterwards
But loses some functionality:
Printing using the Browser print command has to be substituted by programming native print function
This is a tactical decision and the same US2000 Client program can run both ways
Self describing format
Tags or separators around data, like SGML, HTML or XML:
&lt;TAG ATTRNAME=attrvalue&gt; data &lt;/TAG&gt;
or:
data1;data2;data3;
Flexible, but requires parsing
Variable length fields
Like CICS Control blocks:
llbb ll field ll field
where ll is a halfword length field and bb are nulls
Complicated, but uses minimum space
Predefined structure known by both ends
Like a Commarea
AAAABBCCCCDD1234EEE
Uses more space and demands strong data discipline, but is less complicated
Characters only or also binary numeric data?
”High-endian” and ”low-endian”
Visual components are JTextFields, JLabels, and specialised custom subclasses of JTextField
Text properties of visual fields are connected to the field-related properties of the transaction bean with setters and getters
Setters and getters in the transaction bean are moving data between property fields and the Commarea using arraycopy()
The pipeline itself is ignorant of any structure in the data.
The host end of the pipeline inserts the Commarea into a single positional parameter.
The Natural control program subdivides the data into Natural variables
Executes as an applet in a browser window. Can also run as an application
The Web browser gets an HTML page from the server containing a tag identifying a Java applet, followed by the relevant Java classes, including CICS Transaction Gateway classes
The browser displays the US2000 Client and creates a JavaGateway object to connect to a long running Gateway process on the server
Data is displayed entered in JTextFields, validated locally by formatting beans, and assembled into a single printable character buffer by a transaction bean
When the submit button is pressed, an ECIRequest object containing ECI calls is created and sent to the Gateway
The Gateway receives the request, unpacks it, and makes a corresponding ECI call to the CICS Universal Client, which DPL’s it to CICS/VSE
---
User response time is measured as the duration of the call and returned to the mainframe on the next call
To the left is a dynamic menu tree, which is built from downloaded host data
The main window is a multi-document window, which enables the user to keep one window open while using another for an incoming phone call
Each working window is a separate, self-contained entity
An extensive help system is also available
Non-visual components
Common abstract ancestor subclasses Component
Formats and validates data in types like amounts with different width, person identification number, date formats, and lists of what formerly were abbreviated codes
Non-visual components
Abstract ancestor contains the Gateway calls and maps the fields in the A, B, and C segments of the Commarea
The concrete classes maps the variable fields in the specific D segment
Eventually about 100 classes
Any substantial program changes will be in the single abstract class only.
If a new field is inserted, the specific classes will have to be regenerated to change the initial offset into the Commarea
The visual programmer connects the Text property of each JTextField and JLabel to properties of the Transaction Bean
CICS Gateway for Java
Java classes that encapsulate ECI calls
Downloaded from Server machine to Client
CICS Universal Client
Passes data along to CICS/VSE as an ECI Call
Resides on server machine
New name, new version, new packaging, and new pricing of the CICS Client
Available without CICS Transaction Server now
Parameter list passed to Natural
STRTPRMSEQU *RSTRTRID DS CL4Front-end restart trans idPARMADDR DS FAddress of dynamic parms storagePARMLGTH DS HLength of dynamic parm stringTRANSID DS CL4CICS transaction idXCTLPRGM DS CL8Pgm name to Xfer control to
Dynamic parameters
PARMLIST DC C&apos;STACK=(LOGON SYSTEM USERID PASSWORD;CSCSUCAL),’ DC C&apos;PROGRAM=CSCSURET,’ DC C&apos;AUTO=OFF,’ DC C&apos;MENU=OFF,’ DC C&apos;OUTDEST=CSMT,’ DC C&apos;SENDER=CSMT,’ DC C&apos;FUSER=(&apos;????,????),FDIC=(????,????) &apos;
Batch logon, 3GL back end program, No automatic logon, No menu system, Error message Destination, Normal Output Destination, Program location, Data location
EXEC CICS LINK PROGRAM(NATURAL_NUCLEUS) COMMAREA(STRTPRMS) LENGTH(STRTPRML) NOHANDLE
Really just two lines:
CALL &apos;CSCSUBCK’END
Parameter list for Natural
NAT_PARMSDSECT
NATPLIST_ADDR DS FAddress of Natural parameter lst
NATSUB_ADDR DS FAddress of Natural subprogram
USERID_ADDR DS FUserid
ADABAS_TIME_ADDR DS FTimestamp
RETNCODE_ADDR DS FReturn code
RETNMSG_ADDR DS FMessage if RETNCODE is not blank
NATDATA_ADDR DS FAddress of Natural data
NATDATA DS CL1Maps up to 10K Commarea
Call Natural Parameter List Builder Program
LA R1,NAT_PARMSPoint to address listLA R13,SAVEAREAAddress save areaCALL NCIXCPRM
Natural Parameter List
NATPLIST DS CL132
Use the NATCALL interface
MVC CALEN,=H&apos;132’Length of Natural parmlistEXEC CICS LINK PROGRAM(&apos;NCIXCALL&apos;) COMMAREA(NATPLIST) LENGTH(CALEN) NOHANDLE
Operations and monitoring designed into system from day one
A program to monitor server program usage, response time and user
A PLTPI-started program to keep APPC connection to the Gateway alive
A PLTSD-program to generate response time statistics at CICS Shutdown
A dummy return program
Tools for each kind of person
Visual builders
Text editors
Exception eliminators
Bytecode optimisers
Native compilers
Profilers
Obfuscators
The Visual Programmer first places all visual components in the Working Window and then connects the Text property of each Visual bean to the corresponding property in the Transaction bean by dragging a ”rubber band”.
Visual Age understands which type the Transaction bean property is, e.g. MONTH_YYYY.
It accepts the visual connection, if it is possible to create a formatting object of this type in the constructor, and if the toString() method is overridden in the formatting bean.
If the toString() method is not overridden in the formatting object, the connection is illegal, and you get a warning from Visual Age.
This way we are able to make sure that data in US2000 Java Client fields correspond correctly to fields in Natural.
Visual Age translates the drawn connection into two methods to move data in either direction.
One method creates an object of the formatting class with the Visual Bean’s Text property. It then invokes a setter on the Transaction Bean with the object. The Transaction Bean setter moves data to the right offset of the Commarea.
The formatting bean constructor sets its Text property according to its specific formatting rules.
The other method invokes the appropriate getter on the Transaction Bean and casts it to a String. It then invokes setText() on the Visual field with the String.
The Transaction Bean getter creates an object of the formatting class, sets its Text property to the contents of the right part of the Commarea, and returns this object.
When data is changed in either end of the connection (by user input or a successful Gateway call), the corresponding method is invoked.
User interface design
Intuitive
Interactive
Human-oriented
Platform independent
Put yourself in the user’s place
Object design
Inheritance
Polymorphism
Encapsulation
Properties
Methods
Events
Continuous identification of functions to be moved from application to systems programming
If common to several classes
If considered as complicated
Visual Café from Symantec
Market leader, Visual Basic-like
Visual Age from IBM
Smalltalk-like
More than 20 others
New versions all the time
Started with Visual Café 2.5
Too many shortcomings
Changed to Visual Age 2.0
Still no support for latest versions of Java and JFC
Import/export of source to coexist with plain source coding
Supporting the preferred division of work
Support for Visual programming
Support for Java Beans
Support for at least Swing/JFC version 1.0.2
Support for or coexistence with CICS Transaction Gateway 3.0
Availability of external support (education and consultants)
Support for Packages and JAR files
Debugging facilities
Multi-user environment with version control
Automatic conversion of Natural data definitions to Java Beans representing the Commarea
The Commarea Generator program is written in Java and uses the Gateway to have Natural server subprogram source code unloaded by another Natural server subprogram
It analyses the Natural source, extracts the relevant data definitions into a generalised format, and then generates the Transaction Bean that matches the Natural server subprogram
This is accomplished by a simple standard for comments in Natural, eg.:
0290 2 TR-VERSION (N3) /*VALUE=001
0590 2 TR-STOP (N1) /*CLASS=STOP
The generated bean can be imported into and understood by Visual Age
Designed a syntax for comments in the Natural source to ensure that type-specific visual beans are only connected to the corresponding Commarea field types and for initialisation of values where needed
A visual Java development tool shows the properties of a Java bean in a property sheet, where the developer can examine and change values of all exposed properties
The tool is able to analyse the generated Java bean and display both field names and initialised values
Update integrity
Cannot take a read lock not knowing whether the user will continue to work, drink coffee, or go home
Cannot depend on data in client still being valid after operator think time, since somebody else might have updated it behind our back
One solution is to compare timestamps on data and refuse to update if they do not match
Web distribution solves the old version problems
But the most common browsers do not implement Java identically
Can be remedied by using the Java Plug-In
But this is a 7 MB download in itself
Still have to handle interdependencies between
JDK versions
JFC versions
Java Plug-in versions
Tool versions and makes
CICS Gateway Versions
Security of userids, passwords, and data when running on the open network is currently being analysed
End-to-end cryptography?
SSL?
Client and server Java security classes with CSC-developed 1028 bit cryptography?