CA 2E (Synon) Application Modernization – New Demonstration Video

Hello there, I’m John Rhodes of CM First Group. I’d like to talk today about technology to move your CA 2E model applications from RPG and
COBOL to Java, the web, and Cloud. Okay, so here’s what I planned today. I’ll go
through some brief background about the process, about CA 2E applications and how we bring them forward, then I’ll turn things over to Abram
Darnutzer to do a detailed demonstration of the process, really
give you a really clear and detailed understanding about how the CM M3
process works, and then we’ll follow up with some discussion about next steps, if
you’re interested in going forward. A lot of people tell us that they only see two
possibilities there CA 2E applications. Now, first is to rewrite and
replace them with a package, with a custom job application, or something else,
but that’s a very large capital investment. The fact is that most projects
of this nature tend to fail; they don’t meet their budgetary constraints, they
don’t meet their timeframes, they may not meet the needs of the business from a
functionality perspective. Okay, well, I’m gonna cancel halfway through. Okay, the
other option is to leave things as they are, but you know what happens here, okay. It
gets harder and harder to find folks to work on your RPG and COBOL applications,
it gets hard to integrate these with newer technologies that may be running on the
cloud and your technical debt just has to pile up and it gets harder and harder to
maintain these these applications. So, I’d like to talk about a third option, that
is to move the model to a more modern environment, and, that should
generate a modern web app and do that at a very fixed cost, a very
affordable cost. So here’s we hear from talking to CA 2E
customers that are considering this process: first, is they have thousands of
functions and screens to migrate, very large-scale, very difficult projects, okay.
Their system works well, but they want to do something new, they want to be able to
re-platform from IBM i if they desire, they may want to move to a different
database, they definitely want a responsive user experience that works on
a tablet as well as the new widescreen monitors, they want something has APIs
built-in. They want a future that has current tech standards
baked into it, yet budgets are tight and people don’t like risk, and then the
developers that have maintained the CA 2E application must be productive in the
new environment, okay, because they know the business rules, they know the
business, and if they’re not able to understand what’s going on then it’s
probably not a good solution for them. So, we have a long term solution that’s
called CM M3 and the purpose of this solution is really to extend the
economic value of your 2E model by bringing it into a more modern
environment, and then you generate in a very modern solution. Okay, we believe
that this technology requires some pillars really that must be in any
process to modernize 2E. Okay, first is that the automation must approach
100 percent of that because if it’s 90 percent or 80 percent, that extra 10
or 20 percent can really kill you, trying to find the bugs or flaws and 10
percent of the code is truly a mammoth undertaking. Second, okay, the model
environment you have it 2E must be preserved into the new environment; your
developers must be as productive in Plex or more productive than they were
before. Third, the result must be maintainable and
understandable to your existing staff and your new staff that you may choose to
bring on. We must have guaranteed and predictable costs and timelines,
okay, these large projects, you know, it simply can’t fail, they must go as
predicted. And lastly, the result of the modernization must be a responsive web
app with APIs out of the box, okay, or else what is the point, right? So, our
solution, CM M3, really is built on these five pillars. Here’s kind of an overview of how the process works, okay. We look at the CA 2E model and we
also look at the surrounding technology, and RPG, and COBOL, and CL, and other
artifacts are on the IBM i. We run an analysis process over that, okay, we look
primarily the 2E model, but also the surrounding code. Okay, once we do this
analysis we can give you a fixed price for the migration, we can also give you a
timeframe and schedule and plan for the modernization process. Okay, then, we move
into a transformation process where you transform the 2E model into CA Plex,
we help you generate Java from that or C#, we help you generate web and
mobile applications that can stay on the IBM i, but at cost we move to Linux or
Windows or other platforms. I want to stress that it’s not just modernizing
the application, we’re also modernizing the whole way you develop applications,
okay, with a new environment you can generate to modern databases like
Oracle, like MySQL, like SQL server, anything that has a JDBC connection. You’ll be
working with an HTML5 modern interface that runs in a browser, also runs on
devices and resident responsive manner, it automatically rescales to the size of
the device. It will be generating API interfaces the make use of inheritance
and it’s very powerful programming concept, it lets developers to be much
more productive than they can be without the inheritance. We’ll be working in
Eclipse, the visual studio, for your debugging and for your builds, you have
all the power that those platforms have. CA Plex has a very sophisticated
versioning and customization control, it’s baked into the product. You can then
deploy your applications to whatever you want employees to…you can stay on
the IBM i, but you can also move to AWS or Azure, you can also move to any
other platform that supports a Java Runtime, which is virtually anything, and
your developers will be much more productive with all these new
technologies than they were able to be with the limitations they had around
green screen development. Give you a preview of the demonstration Abram will
be doing. We’ll be looking at a really new experience for your existing
business logic. The new experience is going to run on all browsers and it’s
going to run as a device application if you need to desire, okay. The new user
experience will show how the green screen gets transformed to a true Java
web app. This is not a screen scraping situation, it’s a true native Java web
app that you’re generating. Okay, we’ll look at the database, how you can
take the schema that’s on your 2E model and bring that over in Plex and
then generate SQL. We’ll also visualize that schema via ERDs.
We’ll show in the demonstration how you re-platform from DDS running on IBM i, to
alternative data space like SQL server, which we’ll show how that process
works in the demonstration. We’ll also show you how the code gets transformed.
It gets transformed in a very maintainable manner, okay, so you’ll see how the action
diagram 2E gets transformed to action diagram in Plex, how you can visualize
your code in new ways, and how you can just be a lot more productive once the code is
transformed. Then last, Abram will show you how this this application should be deployed as a
Java Web App and really run in any platform, so you can stay on the power,
which is a very very flying platform, but you can also move to Intel, Linux, or
Windows, the cloud, or mainframe, or really any platform that you wish, okay? Okay, Abram, I’m gonna turn things over to you now to do the demonstration Hello, I’m Abram Darnutzer, I’m a senior application consultant for CM First,
and today I’ll be demonstrating the CM M3 process for modernizing a CA 2E
application. In this demonstration we’ll be taking a 2E application written
and generated in RPG and COBOL, and we’ll be migrating that to a Java web
application using CA Plex. There are three main points of this demonstration
that I want to kind of go over. First, I’ll be showing you the database
transformation. We will be migrating the data model from the 2E application to
the new Plex application, so you’re able to maintain your database in the exact
same way you would before and also you’re able to still use your existing
database from your 2E application. I will also be showing how you are no
longer tied to the iSeries for your database, you’re actually able to migrate
your database to anything with a JDBC connection. In this example, we’ll be
using SQL server. The second thing I want to go over is the business
logic transformation, how all of your functions are migrated to CA
Plex and will function in the exact same way
they would in the 2E application. Everything will then be deployed as a
modern responsive web application using HTML5 and JavaScript and
using Java as the backend. Finally, I’ll be showing you development in the tool
using CA Plex and how you will be able to develop going forward and how
everything is created in a way for your 2E developers to transition to
this new environment as easily as possible. So, the first thing I’ll show is
our 2E model. This is the 2E model that was migrated and just to show you
the database relations I’m looking at the applications in C, you can see it is
known by application ID, has a lot of different has fields assigned to it and
also has some other relations to other tables, seeing it refers to the product,
and refers to the person table multiple times, as well as the agent table. And so
you’ll see these definitions now in the migrated Plex model. So, we’ll switch over
to that real quick. And so here’s CA Plex. Everything in Plex is considered an
object, so everything will have certain definitions, and, so, let’s go ahead and
look at the application entity and we’ll see how this is defined. And, so, you can
see here this is the mall editor, this uses what Plex calls triples. These are
all just the definitions of this object and you can see here that we’re still
known by application ID, we have this large array of has fields just as we did
before, and we also maintain all of our reverse relations as well. Another thing you can see here is in the
actual physcal table itself. We maintain all the implementation names that
were being used in the existing 2E applications, so again you can use the
existing physical tables that you’re using with your 2E application, so
there’s no need to migrate if you don’t feel like it, there’s no need to really
change anything if you don’t feel like it.
Another great thing about Plex in the way it kind of can visualize your data
model is you’re actually able to do diagrams within Plex. You can see how,
here I have a small example of how some of these tables relate to each other. You
can see here’s our application table and you can see our refers to for our agent
and our refers to for the person table, in fact you see it referring multiple
times, but then you can also see the relations for the
a person table as well. You can see how it is a, has an own relationship for both
the person photo and person address, and you can also see how the person
addressed relates to, or refers to the state entity. So you can see how all of
your data relates together in a very graphical way from within your Plex
model. So, as I said before, though, Plex is actually very agnostic when it comes to
databases and the entry process really only requires the database to have a
JDBC connection driver for it, which pretty much all databases have at this
point. So, I’m going to go into our Eclipse development
environment real quick and one thing that you can do with your databases is
you can actually setup multiple database connections within the same application.
Here is the example, and I’ll be showing the SQL server database in a
second, but here’s the examples of our two databases, two database connections
that we have set up. Even though they are both connecting to the same database in
this instance, if I wanted to switch this to pull the data from the old 2E
application, so if I’m pulling my–all of the old 2E application data
directly from the iSeries I can also then pull things like my tree
menu, which you will see in a second, so my menu is data driven, and I can pull
that from a separate SQL server environment if I want. And so all of
these things can be configured, and you can switch what database your
application is connected to just by changing a couple of configuration lines.
You can see here I just said what database JDBC database driver I
want to use. Now I make JDBC connection string to handle that, and you can see
here I have some commented out codes for a iSeries of connection and so I can use
the iSeries database connection driver and set up my data source to connect to a
specific data library or even specific library list. So migrating your data is
also possible and so what you see here is our migrated SQL server
database which our migrated application will be running on. And so you can see
here I migrate all my tables using the exact same naming and, excuse me if
I can’t quite remember all the names of everything, there we go, there’s another one. So
you can see here that I have a foreign key relationship for this field. And one
other thing that’s very nice about this is you’re actually not required to use
the iSeries data–iSeries naming you no longer have the length naming restriction
or anything like that so any new data tables you can have you can give it more
meaningful names, for example here I just call this person photo P for a physical
table and had a keyed on it–have it–have a field called person photo and again I
have a foreign key relation to my person table so that will migrate in the exact
same way. So you can actually rename objects from within your Plex model,
regenerate those tables and just do a copy schema from the old table names to
new. Advantages to this come from when you have like third party sources that
need to query your data and they need to be able to understand
what they’re looking at without having to have a sheet assigning and show them
how all the fields relate to each other they can be much more self-explanatory. But again, this is all just optional, if
you want to continue to use your iSeries database, there’s nothing stopping
you from doing that, so that’s very nice about the process. Okay, so now
we’ll go on to our next point: the business logic transformation. So, what we
did–what is done when we migrate and your application is migrated, we will
take everything that was in your 2E model, everything that you set up, all
your local code, how the fields are set up, what kind of functions are being used,
all that will be migrated as is and so I’m going to show a function within the
2E application. And this work with person table. Oops, sorry, wrong key. And so you can see here we have some
local code and three different user points, and initialize subfile control,
initialize subfile control pre-confirm, and process of subfile confirm. I’m just going to
show the code for process subfile control pre-confirm, and so you can see
here we have a simple case statement, we check to see if the command key was hit,
this is for the add button. If so, then we call the edit person table, then we say we want
to reload the subfile. All right, so now let’s look at what was actually migrated Here is the function within Plex, and so
this is the Plex action diagram. The syntax of the Plex action diagram is
very readable and, especially coming from a 2E development environment to this,
it should seem very familiar, just some minor syntax differences. So, what I’m
going to do is I’m actually just going to show the local code in the Plex model
in the action diagram. Sorry. So, you can see here we have some extra user
code here, but this is some of the migrated user code. You can see here that
the, in Plex we have a thing called edit points and these are basically the same
thing as user points within the 2E environment, except in Plex you’re much
more free to create new user points, put them anywhere in the code, edit code in a
lot of more different places than you would in 2E, so you have a lot more
customization options, but let’s go ahead and just expand these, and you can see
here we have code that looks very similar to code you would see in 2E. And
here’s the specific example that I just showed you. This is user process subfile
pre-confirm, you can see that we have code to check what command Q is pressed.
If it was add, we come in, we call an insert person table and then we reload
the subfile. We can even look at the parameters being passed, we’re passing a
specific ID value which I believe has a literal value of zero, and you can see,
I’m sorry, you have -1 actually, and so you can see we have the exact
same thing that we’re doing here. So all the code was migrated in the exact same
way and the patterns are set up to behave the exact same way the 2E
would behave. And, so, let’s go ahead and show the application then, show it
running. Here is just a simple login screen, we’re just gonna go and
login, and we’re going to load up our menu. First thing I want to do before we
get to our functions give you a small tour of the application. This is the
out-of-the-box menu system that comes from an M3 process. You can see here we
have an accordion menu here on the left. Everything in the menu is data driven.
These things can all be stripped out of the menu data files that you’re using
for the original 2E application and applied here and then customized in any
way that you see fit. And, so, let’s go ahead and go to the person function, and
we’re going to go ahead and call it, and you can see here this looks kind of
similar to a 2E screen, and actually let’s go back to the 2E screen
and I’ll just show you exactly what it looks like. And you can see here we have
a large header areas where I say work with person entries, we have a static CTL
field here, we have three subfile op– three subfile options, and then we
have two F key options, and we also are able to filter on the last name. So, let’s
see how we migrated this then. So, what you see here is, I just kind of edited
the header, so instead of saying work with person, it just says person because it’s
much more concise and I feel like it’s a little more modern user-friendly way to
say something. You can also see here we have our F key buttons, all F key and subfile options are migrated as buttons by default. So, out of the box all these
things are here in the way they are. Other thing that’s kind of nice about
this, though, is all the F keys still work, so if you have a bunch of power users
who are just so used to using the application in a specific way, they can
still use those F keys and then they will still work. Another thing you may
notice is the subfile entry. We no longer have an edit box where we just type in
the subfile option that we want. Instead, here we just have a check box
where you would check what you want to run and then you run the specific subfile
command in on that option. And, so, for here I’ll just go and look at the
address of this person and we’ll call the address function. So, let’s go ahead
and go back to this. I just want to make a point that this is just the out of the
box subfile interaction that we kind of
have. If there is some other idea or some other way you want to customize how they
want–how you want your users to interact with subfile, that can certainly be put in
the patterns and affect everything throughout the application. So, some other
things I kind of want to touch on here is, let’s go ahead and just show that the
filter, filtering still works. So, again, just functioning exactly the
same as it would for your normal 2E users. One great thing though about this
process in the migration and bringing it into a modern web app, it’s not just a
screen scraped app. It is a true HTML5 JavaScript app that is dynamic and you
can kind of customize it to fit however you want it to fit. And, so, you
can do things that were not possible, that aren’t typically possible in just
screen scraped applications. So, here, let me go ahead and clear my filter, and go
into the addresses here, and just to show you for a quick example, sorry, zoom out
we have Google Maps integration directly in. And this is nothing mind-blowing, but
this is something that would not be possible at all within your 2E
application. So, the migrated app is a full HTML5/JavaScript application.
Anything that you can think of doing within HTML and JavaScript, these can be
put into your application. So, to go back just to show some other examples and
things that kind of come out of the box even: so out of the box all of your
subfile functions have the ability to export to PDF and to a CSV file. So, just with
one click of a button, the application can read the data, and then export that
to a CSV. So, if you, again, if you have some third-party app that you need to
get your information out, information out to another client or another group of
people, you could easily do that from within the application without having to
go through some other complicated means. Other things that are that are great: you
can initiate emailing directly from on the application, you can
pre-populate emails, you can even do email servers just directly from the
job itself too, if you want to attach files and things like that automatically.
If you’re on a tablet, what you can’t do here because I’m on an desktop, you can
actually initiate using the phone on a– make an actual phone call on the phone or
tablet depending on how you have it set up. You can link to help systems directly
from within, and these are things that you can put back in the Plex patterns
and have available throughout your application, so you can add this help
system link in one place and it will automatically be in everything that is–
in every–every screen function within your application. Other simpler items,
like just displaying a PDF directly embedding it directly within your
application and within a page you can do that, and embedding Word documents
directly within a page, you can do that. There’s nothing really stopping you from
doing all these custom things. And another thing about migrating your
application is you are no longer stuck with developing things in the way
that you had to develop them in 2E. You can in Plex you give you much more free
form and develop things things in completely different ways than what
was possible before. So, as an example, I’m going to open another version of the
person step, and one thing that you might have noticed here is it opens a new tab.
Basically the out of the box menuing system will treat every menu item call as their
own–as equivalent to their own green screen emulator session, so you
can have multiple versions, and even the same function open, and do
work, and come back and forth, and so your your clients and your users workflow can
be as efficient as possible right out-of-the-box with the application. So,
to go back, this is just a simple example of a custom grid. This is just grid data
display it in a much more visual way from within the application, so if you
have some system where more pictures are much more important than worth a
thousand words and will help the user be more efficient and understand what
they’re looking at and interact with the data better, you can put that directly in
the application and then you can still have these functions function–work
kind of with the same flow, so you can see here I can call
same existing address function that I had before, view the map on it, do
whatever I need to do. So, you can have all these things work in the exact same
way, but just present them in a completely different way. Another example
of how to present things in a completely different way: here’s the same person
function, except we’re using a tabbed interface allowing you to mess with
subsystems of the person table, and even the person’s details themselves. And you
can also see we’re using just a more normal grid interface, but inserting
pictures and photos within that as well. So, if you still want to use like a
more normal grid system but, again, a picture would be much better, or a much
better way to get information across to your users, you’re able to do that. And
then also you can see down here we have dynamic graph–JavaScript graphs being
written, being graphed purely on data that we’re loading into a grid, so you
can have dynamic charting and graphing within your application to
further visualize your data and make it easier and more efficient for users to
interact with. So, the migrated application is very powerful and very,
really the only limitations are your imagination and really what you want to
do with it. So, you’re no longer just screen scraping an app and putting it
out on the web you have a true responsive HTML5/JavaScript application. Okay,
so just set some small–I just showed some small examples of the actual
business logic itself, so now let’s go into the actual tool that we
will be developing in, looking at Plex and looking at Eclipses, the Eclipse
environment and how all this works, and then looking at the one of the real
powerful things about Plex, and I mentioned it a few times but have not
gone into detail, but the inheritance in Plex. So, let’s go and look at the model
again. So, first I’m going to look at the triples of a couple of functions. These
are the–this is the custom HTML grid function. You can see here, in Plex, to
inherit from something else you say that item is something else.
So, if function A needs some functionality that needs all the functionality is
available in function B, you could say function A is function B, and then
function A will automatically have all the things that function B had, and then
you are actually able to further tweak that and customize it to fit whatever
function A’s needs would be. So, we’re gonna do a simple example here. We have
in our custom HTML function, you can see we’re inheriting from a function called
“hello world”. Same thing for our tab. Down here you can
see “hello world” and so what is the “hello world” function? I’m just gonna go ahead
and open it, and I’m just gonna open the panel for it and you can see simply we
just have a button that says hello– that’s called “hello world” and I’m
looking at the events that– that correspond with this button when I
click, when I have the physcal event of press, so basically one click of the button, I’m
triggering a logical event in the code called “hello world”. And, so, let’s go in
the action diagram, look at the events. You can see I have my logical event code
for “hello world” and you can see I have a dialog message where I’m going to say
“hello” and then I have an actual parameter that I’m going to be passing in. So,
you can see here I’m passing in a greeting for “hello” to “world”. And, so,
basically by default, for anything that inherits from this, they’ll have a button
on there called “hello world” and when they click it it’s gonna pop up a dialog
message that says “hello world”. So, now let’s actually look at one–at the
examples that are actually using this. And let’s look for “hello world”. And, so,
here’s our “hello world” and you can see here that–so in Plex, everything that’s
inherited is kind of grayed out, just to show that you’re not able to directly
fully edit it, but you are able to tweak and override code and things like that. So
here, in the actual parameter mapping I’m doing a local override. And, so, you can
see here I’m changing the greeting to be “Abram”. And, so, on this function actually
instead of saying “hello world” it’s going to say “hello Abram”, so it inherits all the
code that the “hello world” function had, but I’m able to kind of override and
tweak it a little bit. Okay, so, let’s actually go see this at runtime.
So, here is the normal tabbed one, this should be doing the default, so when I
hit “hello world” you can see pops up a dialog that just says “hello world”. And as I go
in the person tab version, you can see once I click “hello world” it’s actually saying
the “hello Abram”, which is the message I overrided with. Now, I understand that
this is a very simple example, but you can kind of see how you can put code
back in a pattern that everything uses and then, for example, your security
functionality, this is the best example I can always give. If you want some
security functionality that you want every function within your application
using, you can write that security functionality once put the inheritance
for it back in–far back in the patterns, some place you know that every function
or all your screen functions or whatever you want this to go on uses, and that code
will automatically be put in all those functions. And to show you kind of how
this kind of works, you can see here I’m going to look at the actual
inheritance path of my person tab function, sorry…okay, so, you
can see here that as we go up we see all the things we inherit from, so you can
see the last thing I inherit from, which is my “hello world”, you can see I’m doing
other things like initialize my map, I’m adding the tab strips, you can see I’m
putting some hidden–this is just getting more and more in to standard Plex
inheritance, but I’m just doing a standard UI function, this is what gives
me my panels. And you can see I have just a normal function show, which sets
up just basically the layout of my action diagram. So, you can kind of see
the inheritance all the way here. And, so, let me go ahead and show you the
inheritance of the work with persons table that we looked at earlier.
And you can see here, as we inherit we’re just inheriting things for look and feel,
but you can see here we’re inheriting something called display file and this
is the pattern that is created to to take your normal display file
functionality and bring that into the migrated environment. So, everything
that inherits from display file will will be your–what was your display files
in 2E and so will behave exactly the same way throughout the
application for all your display files. And, so,
then all you have to worry about from there is once your thing inherits from
this display file, you just have to worry about the custom code on top of that in
this exact same way you would develop in 2E. And, so, you can see here that
what we’ve really done here is to try to make your application a
easy transition for your developers. If you are trying to take your 2E
application and migrated to just pure Java, you wouldn’t–your entire 2E
development group would have to learn how to develop in pure Java
which is a much steeper learning curve than what we have in this process. And, so,
in this process you can see everything is named in a way that’s familiar to
the 2E developer, the syntax is very similar to what you would see as a 2E
developer and so the transition is much easier for you in this circumstance.
And, so, finally I want to just kind of give a small tour of the Eclipse
development environment. In the Eclipse development environment this is
basically what’s handling, actually building all of our Java code and
deploying everything out into the web. And, so, here’s an example
of our work with persons table and, here, if I can go back to the Plex model,
you can see here if I go down in triples, it has an implementation name of
INA0DFR. And, so, you can see in the name of the tab INA0DFR, so
everything, all the naming is all similar to what you had, so if you ever want to
find a function and debug it and see what it looks like,
you just look for the exact same implementation name. And you can see here
in the actual source code, there’s comments of the exact action diagram
statement that is being run, so your transition into debugging this is much
simpler because you can see exactly what’s related in the Plex code itself. So, again,
everything from implementation names, names to functionality to field
implementation names, field behaviors, field lengths, values under those fields states under those fields that you use
for comparisons, all of those things are migrated directly into the Plex
application to make it work and function the exact same way that it did when
you’re developing in 2E, except now you have a much more modern, more powerful
development environment and you have a rich web application that you’re
able to take to stay with modern development standards and to keep
everything as fresh and new as possible. And the web environment is
so open-ended that you’re able to keep up with whatever trends and whatever UI
and whatever user interface ideas that you want to implement. So, that’s it for my demo.
Thank you so much and back to you, John Well thank you Abram, that
was a really excellent demonstration. I hope everyone got a really clear
understanding about how our process works and what you end up with out the
backend. Okay, if that was interesting to you, and I hope it was, we talked a little
bit about the next steps. Okay, so we have a process to help you make an informed
decision for modernization. Okay, we start off by doing an automated analysis,
okay, and that means we give you some scripts to run, you run these scripts
over your model, get some metrics back to us on counts of objects from the model.
From those counts we can give you a very clear picture about what the cost will
be for the project you want undertake. Okay, assuming that meets your
expectations, then we move to a second phase. Okay, in the second phase we do a
combination of POC–proof of concept–and deep analysis. Okay, so, we spend usually
six weeks, we usually go on-site for a week, work with your subject matter experts,
we get access to your models, and we work with you to develop a plan and
proposal to do the modernization, and that will cover all aspects of the
modernization, okay, from the automated part to the acceptance testing to
getting your developers trained and really all the aspects to make you
successful with the modernization. So, you have a really clear idea about what
you’re getting into, okay, and then you can make a very informed decision then
to go forward or maybe to wait to a more opportune time. Okay, so, I’d love to
talk to you about this we can be located at and we welcome
your questions and your inquiries on this technology. Thank you.

Leave a Reply

Your email address will not be published. Required fields are marked *