►
Description
Mainframe DevOps and Modernization - Daniel Kelosky & Michael Bauer, Broadcom
This presentation will show traditional mainframe development practices and interfaces and how the practices and interfaces can be modernized with Open Mainframe Project's Zowe framework. The session will be in the context of C and assembler language software development for z/OS, but the concepts apply to other language development for mainframe, like PL/1 or COBOL.
For more Continuous Delivery Foundation content, check out our blog: https://cd.foundation/blog/
A
I
started
as
a
software
engineer
at
ca
technologies
now
broadcom
working
on
mainframe
applications
a
little
over
six
years
ago,
and
when
I
first
started,
I
went
through
a
training
program
to
learn.
The
tools
of
the
trade
and
dan
will
talk
a
little
bit
more
about
that
developer.
Experience
later
on,
but
then,
a
few
years
ago
I
transitioned
into
a
product
owner
role
for
what
is
now
the
zoe
cli
and
the
zoe
cli
as
we'll
talk
about
is
a
technology
that
enables
you
to
make
use
of
modern,
distributed
development
technologies.
A
A
We
got
an
action-packed
agenda
for
you
today.
I
will
kick
it
off
with
what
is
a
mainframe
and
why
it
is
important,
then
I'll,
send
it
over
to
dan
for
a
demo
of
today's
developer
experience
on
the
mainframe
and
then
we'll
we'll
come
back
with
what
is
zoe,
why
it
is
important
and
how
it
can
modernize
the
mainframe
development
experience,
and
then
dan
will
show
us
that
with
a
demo,
so
to
start
off
what
is
a
mainframe?
A
A
B
B
I
have
worked
for
another
software
company
building
out
software
for
non-mainframe
platforms,
but
other
than
that
one
year.
This
is
mostly
what
I've
been
doing,
and
so
I'm
going
to
walk
through
an
example
of
what
it's
like
to
build
software
for
the
mainframe
platform
in
a
traditional
development
environment
in
some
of
the
cdcon
material.
B
B
Cos
is
an
operating
system
for
the
ibm
maintenance.
There
are
others,
but
zoos
is
what
most
are
familiar
with.
Of
course,
that's
for
people
that
are
familiar
with
mainframe
in
the
first
place
to
get
started
using
zos,
the
user,
typically
logs
on
to
tso
pso,
stands
for
time,
sharing
option
and
pso
by
this
ready
prompt
here,
that's
on
my
screen
and
tso
is
just
a
user
interactive
session
with
with
see.
What's
from
here,
you
typically
launch
a
panel
application
called
ispf.
B
If
I
want
to
build
some
code,
I
need
to
navigate
to
my
data
sets.
I
did
that
with
a
command
3.4.
To
get
to
my
data
set
list
data
sets
our
files
on
odds
us
we'll
leave
it
at
that.
If
I
want
to
create
a
program,
I
need
to
create
a
file
in.
One
of
my
data
sets
there's
a
lot
of
history
here,
a
lot
more.
We
could
talk
about
for
historical
reasons.
Member
names
contained
within
the
data
set
are
restricted
to
a
character.
B
So
if
I
want
to
make
a
hello
world
program,
I
need
to
select
the
name
for
my
hello,
eight
characters
or
less
so
I'll
truncate.
This
I'll
call
my
program,
hello,
world.
Don't
read
into
that!
I,
like
I
love
coding
on
mainframe,
I'm
not
trying
to
say
this
is
hell
world.
This
is
how
I
create
a
c
program
on.
B
Real
quick,
I
want
to
go
back
to
the
slides
before
we
show
what
it's
like
to
build
out.
This
hello
world
c
program
in
an
ispf
editor.
Looking
at
this
program
in
its
entirety.
I
said
it's
a
hello
world
c
program,
but
there's
some
other
things
going
on
here.
If
you
know
the
c
language
it
might
help,
but
it's
not
required
here.
Typically
in
a
hello
world
c
program,
you
have
your
main
function
and
then
the
body
would
be
a
function,
call
to
printf
and
hello
world
and
printf.
B
If
I
coded
that
function
here
would
have
write
hello
world
to
standard
out,
and
that
would
be
all
that's
needed
for
hello
world
again.
I
have
some
other
things
going
on
here.
I
happen
to
have
an
s
printf,
which
is
somewhat
similar.
It
has
some
of
the
capabilities
of
printf,
but
it
doesn't
write
to
standard
out
and
then
I
have
this
line
at
the
bottom
return.
7.,
the
seven.
The
number
seven
is
completely
arbitrary
here,
but
I'm
using
that
to
illustrate
a
point
which
I
hope
to
make
on
this.
B
This
next
slide,
so
that
hello,
world
c
program
is
actually
a
hello
world
metal
c
program.
Metal
is
a
keyword
on
the
ibm
c
compiler
that
says
I
don't
want
this
code
to
be
dependent
on
any
run
time,
so
metal,
meaning
not
depending
on
the
runtime
running
close
to
the
hardware
of
the
bare
metal
and
since
it's
running
close
to
the
hardware
bare
metal.
When
I
code
some
metal
c
and
I
compile
it
what's
actually
generated
from
your
output
for
me-
is
assembler
statements.
So
this
is
ibm
mainframe,
assembler
statements.
B
Following
this
return
statement,
I
coded
a
return.
Seven,
it
happens
to
be
a
seven
on
this
next
instruction,
which
is
loading
the
number
seven
into
a
register
15
and
then
some
other
stuff.
That's
going
on
here
I
tried
to
frame
this
presentation,
or
example
of
traditional
mainframe
development,
of
in
what
I
actually
do,
which
is
write
back
end
system
level,
code
for
the
ibm
mainframe,
so
that's
metal,
c
code
interfacing
with
the
sampler,
but
I'm
going
to
stick
to
c.
B
B
So
I'm
going
to
show
building
a
c
program
by
hand.
This
might
go
just
a
little
bit
slow,
but
that's
that's
kind
of
the
point.
Remember
we
want
to
talk
about
how
we
can
deliver
software
with
greater
speed
and
the
way
I
want
to
do
that
is
show
how
it's
currently
slow
today
and
that's
a
technology
that
makes
this
development
experience
a
little
bit
faster
and
better
I'm
using
the
ispf
editor
and
I'm
going
to
just
try
to
code
up
the
c
program,
ideally
without
making
any
mistakes.
B
A
B
Other
blank
line
ispf,
I
actually
don't
have
a
problem
with
this.
As
a
code
editor,
I
think
it's
kind
of
powerful,
especially
for
certain
column,
oriented
languages
like
cobalt
or
assembler,
but
there
are
some
other
quarks
that
make
this
a
not
ideal
environment
for
building
out
new
software,
things
like
intellisense
or
navigating
symbols,
or
just
be
able
to
hover
over
a
data
type
and
see
it's
value.
B
I'm
going
to
start
with
just
a
hello
world
program
and
a
return
here
actually
I'll
make
this
a
7
as
it
was
in
the
presentation.
I
won't
code
those
other
pieces
for
now,
but
this
is
a
hello
world
program
in
ispf
that
I
coded
to
get
to
see
what
the
interface
looks
like
again,
there's
no
intellisense,
I
can't
click
and
navigate
to
this
header
file
and
see
definite
conditions
in
there.
B
So
I
went
ahead
and
filled
out
the
rest
of
this
program
offline.
So
you
didn't
have
to
see.
See
me
type
it
all
out
what's
been
introduced.
Here
is
the
remaining
of
the
code
almost
for
beta,
as
you
saw
on
the
slides
this
wto
underscore
buff
piece.
Is
a
structure
defined
in
this
w-2.h
header
file,
as
is
this
function
w-2?
B
So
wto
stands
for
write
operator,
it's
a
low-level,
assembler
base
service,
and
so
the
code
in
this
wql.h
is
the
assembler
code
that
wraps
and
makes
this
callable
from
lc.
If
you
recall,
I
don't
have
a
full
runtime
available
to
me
in
this
middle
c
environment.
I
do
have
some
runtime
built-in
functions.
For
example,
a
spread
f
function,
so
I
can
take
a
message,
a
c
format
string
and
build
that
into
a
buffer
and
I'm
doing
that
with
the
sprint
function.
B
B
So
I'm
going
to
create
some
jcl
similar
to
how
I
created
my
c
program
in
a
cos
data
set.
So
I
create
this
hello
world
jco.
The
way
most
people
create
jcl.
As
far
as
I
know,
is
they
copy
from
jcl.
That
does
what
they
already
need.
It's
very
rare.
I
see
people
create
jcl
from
scratch.
You
have
some
jcl
that
somebody
built
a
long
time
ago
and
you
copy
it
and
tailor
it
to
what
you
need.
B
Next
I'll
invoke
the
ibm,
assembler
jcl
runs
sequentially,
some
number
of
programs.
So
the
next
thing
that's
wrapped
up
here
is
it's
going
to
go
the
assembler
to
take
my
assembler
code
and
emit
object
code,
then
my
object
code
will
be
linked
or
through
the
us,
ibm,
linker
or
binder
and
create
the
final
executable.
And
lastly,
this
jcl
will
run
my
program.
B
B
B
B
B
And
I
made
a
mistake:
while
I
was
doing
that
this
is
a
deeply
manual
process
very
error-prone.
Another
reason
why
why
it
slows
down
software
development,
this
traditional
interface
there's
a
lot
of
data
on
the
screen.
Two
things
to
catch
this
tool,
I'm
showing
here
is
sysview
a
way
to
do
job
output
from
a
program
you're
in
it's
a
batch
job.
The
c
code
is
the
condition
code
and
the
output
is
seven
because
my
my
program
had
a
return
code.
B
B
B
All
right
so,
having
seen
the
example
of
what
it
looks
like
to
build
c
program,
run
it
on
mainframe.
The
one
thing
that's
missing:
well,
maybe
several
things
are
missing:
modern
tools,
modern
version
control
software.
There
is
version
control
on
mainframe,
but
you
didn't
see
it
in
the
picture
there.
A
A
A
A
A
Modern
development,
tooling,
with
z,
os
and
the
cli
itself,
can
be
extended
through
plugins
for
various
mainframe
services.
Here's
a
view
of
all
the
different
developer
technologies
that
are
enabled
by
zoe.
So
starting
from
the
top
left.
We
see
the
zoe
command
line
interface,
there's
a
variety
of
groups.
You
can
look
into
each
group
for
actions
and
objects
on
which
to
take
those
actions
and
build
out
your
commands.
A
Once
you've
mastered
running
the
cli
interactively
as
you
can
see
in
the
middle,
you
can
abstract
that
into
scripts
of
your
own.
Maybe
you
use
golf
tasks
or
npm
scripts,
maybe
just
shell
scripts,
or
what
have
you?
You
can
begin,
writing
your
own
automation
and
then
ultimately,
including
those
in
the
jenkins
file,
maybe
running
the
jenkins
pipeline
or
other
cicd
tooling.
A
A
Also,
I
mentioned
that
zoe
is
a
platform,
but
it
doesn't
just
stop
with
what's
available
in
the
open
source
community,
but
vendors
like
phoenix
software,
international
broadcom,
ibm
rocket.
Software
engineering
have
all
built
commercial
extensions
on
top
of
this
platform,
which
extends
the
number
of
services
you
can
now
access
remotely.
A
A
You
can
leverage
your
cicd
tooling,
of
choice,
whether
that
may
be
jenkins.
You
can
use
your
source
control
that
you
want,
such
as
github,
etc.
So,
with
this
platform,
it
really
enabled
the
use
of
all
of
the
different
distributed
technologies
that
are
out
there,
and
it
also
makes
scripting
on
the
mainframe
a
lot
easier.
A
So
there
are
ways
to
script
on
platform,
but
there's
not
as
many
libraries
available
to
share
so
just
for
example,
as
many
of
you
know,
there
are
many
packages
on
sites
and
registries
like
public
npm,
for
example,
has
1.3
million
software
packages
or
pipe.org
has
over
250
000
packages
that
you
can
go
out
and
leverage
to
help
modernize
and
streamline
your
development
processes.
So
with
that
I'll
now
turn
it
over
to
dan
to
give
us
a
quick
demo.
B
Great,
so
I'm
back
thanks
mike
for
the
description
of
zoe
and
for
all
the
parts
of,
but
the
two
pieces
that
we'll
make
use
of
on
this.
This
next
piece
is,
of
course,
apis
on
the
mainframe
to
facilitate
uploading
and
downloading
files
to
zos
datasets
and
also
viewing
my
drive
output
and,
of
course,
the
apis
are
going
to
be
consumed
by
iso
and
cli.
B
Okay,
for
a
second
and
final
final
demo,
we're
going
to
look
at
zoe,
cli
and
then
building
this
hello
world
llc
program,
first,
just
to
see
zoe
cli
in
action,
I'm
going
to
issue
a
command
zoe
x,
jobs
list
jobs
and
without
trying
to
make
sense
of
all
this
data.
One
thing
that
you
should
probably
recognize
is
this,
so
the
zoe
x,
john's
listening
is
displaying
the
information
you
saw
on
that
that
green
and
black
screen,
where
I
could
see
that
my
program.
B
To
seven
and
I
could
see
the
output
now,
I'm
gonna
not
going
to
all
the
details
of
all
the
different
zoe
cli
commands,
but
you
can
job
information,
upload,
download
files,
but
the
real
power
I
think
in
zoe
cli-
is
wrapping
up
so
cli
and
some
scripts
automation.
So
here
I'm
using
a
little
javascript
script
for
node.js
to
run
zoe
click.
This
is
just
an
example.
B
B
B
I've
wrapped
up
zoe
commands
behind
my
own
scripts
that
are
prefixed
that
are
that
are
encapsulated
into
this
cdf
command.
So
I
have
a
z
upload,
which
issues
a
bunch
of
zoe
upload
commands
where
I
have
a
cdf
make
which
is
going
to
run
off
and
invoke
my
build
job
or
then
I
have
a
zdf
run
actually
and
then,
because
there's
lots
of
cool
extensions
and
ways
to
extend
microsoft,
vs
code,
I
can
give
these
labels
to
my
various
tasks
in
here
like
run
build.
I
can
also
put
emojis
in
there.
B
A
B
And
I
can
click
this
run
button
behind
the
scenes.
My
tasks
are
executing
to
upload
the
changes
I
made,
whichever
source
files
changed,
invoke
the
build
job
and
actually
run
my
program
and
direct
the
output
right
back
to
my
terminal
window.
So
before
when
I
had
to
view
the
job
output
to
assist
you
now,
I
can
see
my
output
right
here
in
the
terminal
on
sidebar.
B
The
green
screen
operations
and
things
I
had
to
do
behind
this
before
again,
there's
a
lot
going
on
behind
the
scenes
with
that
base
level
of
command
line,
calling
back
to
a
rest,
api
and
mainframe
and
exposing
mainframe
services
to
apis
easy
cli.
Wrappers.
In
front
of
that,
I
can
wrap
that
up
about
script.
Automation
improve
my
developer
experience.
I
think
I
can
make
code
change
much
faster
than
I
could
before,
and
then
I
could
also
begin
to
wrap
this
up
in
some
test
cases
assert
that
the
output,
as
I
expected.