IBM z14 Mainframe: Tighter Security, Greater Capacity, New Optimizations

IBM z14 Mainframe: Tighter Security, Greater Capacity, New Optimizations

Today, IBM announced what we’ve all been waiting for. The z14 mainframe has been unveiled, along with several performance optimizations. We can expect to see the latest evolution of Big Iron in datacenters later this year (see the z14 mainframe announcement letter for further details).
As Compuware explained in a press release detailing its day-one support of the z14 mainframe, to the advantage of joint Compuware and IBM Z customers, “The z14’s new features, particularly greater security enabled through pervasive encryption, will help Compuware customers optimize ‘digital trust’—heightening user confidence that their sensitive data is being kept safe and secure.”
Mainframe users have long championed the platform’s unmatched securable environment. It is virtually impenetrable, unlike distributed systems. The only easy way to “hack” a mainframe is from the inside, but that’s becoming a greater concern.
Pairing the z14 mainframe’s tighter security, which Compuware says will provide “extensive encryption of data, both in-flight and at-rest,” with tools like Compuware Application Audit, which provides end-to-end visibility into privileged user behavior, companies will be able to improve safeguards against insider threats to mainframe applications and data.
Alongside improved security, “Additional hardware capacity and performance optimizations will also help customers more fully leverage their mainframes as a competitive asset,” Compuware says.
The announced IBM Enterprise COBOL V6.2 and PL/I V5.2 compilers continue to provide exploitation of IBM z/Architecture by direct support for the z14 hardware and z/OS V2.3 software.
The new compilers will include direct support of the new z14 hardware by use of the ARCH(12) compile option and will include exploitation of the z14 Vector Packed Decimal Facility without customer source code changes. COBOL V6.2 also includes many of the COBOL V6.1 CD – Continuous Delivery – items that were PTFs in the past six months that assisted migration from previous COBOL compilers. PL/I V5.2 also adds performance, usability and additional client requested enhancements.
IBM’s z/OS V2.3 provides the software framework to exploit the z14 and provide enablement services to COBOL and PL/I so customers can continue to modernize applications to meet their digital transformation requirements. Especially notable are the new z/OS V2.3 policy based encryption options that will enable use of pervasive encryption, without application changes, to protect customer data and meet new compliance requirements.
If the world was surprised at how modern the z13 mainframe is two years after its release in 2015, what will it think of the z14 mainframe?
With companies like Compuware proving Agile and DevOps are feasible on the mainframe, and with IBM instilling those practices directly in the platform, and synergizing them with tighter security, one need not speculate as to where the mainframe is headed as the core system of record supporting the private and public sectors’ most mission-critical apps and data in the digital age—it’s certainly not to a burial plot.

http://insidetechtalk.com/ibm-z14-mainframe/

IBM Z Mainframe Runs Universal Encryption Quietly in the Background

By: Chris Preimesberger | July 17, 2017

• Twitter

  Facebook

  LinkedIn

  Google

  Email

  Share

  Twitter

  Facebook

  LinkedIn

  Google

  Email

Big Blue said this newest mainframe is its most significant system overhaul in 15 years. It was designed with input from 150 clients who cited data breaches and encryption as their biggest challenge and concern.

Data encryption has always been a pain in the patootie for anybody charged with making sure all of an enterprise’s data is tightly protected during its lifetime.
While an increasing number of x86-type server systems and consumer PCs are now using various encryption approaches, not much has been happening regarding the use of encryption in mainframes, which still comprise a healthy percentage of all the computing done in the world.
As of July 17, a lot more is now happening in mainframe encryption.
IBM announced that its new IBM Z mainframe will be able to encrypt all the data in an enterprise all the time—and without users even knowing that the documents they are accessing and sharing is encrypted. It’s literally pervasive encryption.

Further reading

• Cisco Launches Gen 5 UCS Servers
• Open19 Foundation Debuts to Create Standardized Servers

Biggest Mainframe Advancement in 15 Years, IBM Says
Big Blue said this newest mainframe is the most significant system overhaul in more than 15 years. It was designed with input from 150 clients who cited data breaches and encryption as their biggest challenge and concern.
Encryption has always been expensive and takes a lot of computing cycles to encrypt small chunks of data at a time, so a lot of time and power is always required. Not so with this new IBM system, which is automated and works as quietly as an international spy in the background.
“Our customers around the world that called out for a different approach to solving the problems with perimeter defenses that most companies need,” IBM Vice-President of Offering Management for Z Systems Mike Desens told eWEEK. “So, based on those core competencies we had in the mainframe, the CISOs we’ve been working with defined this capability to do 100 percent encryption of all your data—without having to have any application changes or impacts to your service-level agreements.”
This new capability lays encryption on everything—and not only through mainframes. The encryption follows the Z system data store from cloud services to databases, and it’s extremely scalable. The IBM Z is capable of running more than 12 billion encrypted transactions per day.
Changes the Approach of Encryption
“This changes the approach from a straight perimeter defense to where the data is; that’s where the (new) perimeter is. By encrypting the data, even if those bad entities get into your data center and behind your firewalls, they’re getting access to encrypted data, which is useless,” Desens said.
This is IBM’s front-line response to the problem of data breaches and enterprise compliance—encrypting entire workloads all at once. The company said that in 2016 more than 4 billion data records were compromised, a 556 percent increase over 2015. Of the 9 billion records breached during the past 5 years, a mere 4 percent were encrypted.
Key takeaways from this news include:
--Encrypts all data, all the time: IBM Z for the first time makes it possible for organizations to encrypt all data associated with an entire application, cloud service or database in flight or at rest with one click. The standard practice today is to encrypt small chunks of data at a time, and invest significant labor to select and manage individual fields. This bulk encryption at cloud scale is made possible by a huge 7x increase in cryptographic performance over the previous generation z13, driven by a 4x increase in silicon dedicated to cryptographic algorithms.
--Tamper-responding encryption keys: A concern for organizations is protection of encryption keys–an extreme version of the problem faced by millions of consumers with increasing complexity and vulnerability of passcodes. In large organizations, hackers often target encryption keys, which are routinely exposed in memory as they are used. IBM Z can protect millions of keys (as well as the process of accessing, generating and recycling them) in “tamper responding” hardware that causes keys to self-destruct at any sign of intrusion and then reconstituted in safety.
The IBM Z key management system is designed to meet Federal Information Processing Standards (FIPS) Level 4 standards, where the norm for high security in the industry is Level 2. This IBM Z capability can be extended beyond the mainframe to other devices, such as storage systems and servers in the cloud. In addition, IBM Secure Service Container protects against Snowden-style insider threats from contractors and privileged users, provides automatic encryption of data and code in-flight and at-rest, and tamper-resistance during installation and runtime.
--Encrypted APIs: IBM z/OS Connect technologies make it easy for cloud developers to discover and call any Z application or data from a cloud service, or for IBM Z developers to call any cloud service. IBM Z now allows organizations to encrypt these APIs–the digital glue that links services, applications and systems–faster than alternatives based on x86.
The IBM Z also is designed to help clients build trust with consumers and comply with new standards such as the EU’s General Data Protection Regulation (GDPR) that increase data compliance requirements for organizations doing business in Europe starting next year.
GDPR will require organizations to report data breaches within 72 hours or face fines of up to four percent of annual revenues unless the organization can demonstrate that data was encrypted and the keys were protected. At the U.S. Federal level, the Federal Financial Institutions Examination Council (FFIEC), which includes the five banking regulators, provides guidance on the use of encryption in the financial services industry. Singapore and Hong Kong have published similar guidance.
More recently, the New York State Department of Financial Services published requirements regarding encryption in the Cybersecurity Requirements for Financial Services Companies.
--Streamlines compliance: Auditors now are expected to manually inspect and validate the security of databases, applications and systems. IBM Security tools and IBM Z for the first time make it possible for organizations to streamline this process–taking data and applications out of scope of compliance by automating the verification that data is, in fact, encrypted and that the keys are secure. This will reduce the complexity and mounting cost of compliance for auditors. The system also provides an audit trail showing if and when permissioned insiders accessed data.
In an example of IBM Z as an encryption engine for cloud services, IBM today announced the opening of six new IBM Blockchain Global Data Centers in New York, United Kingdom, Frankfurt, Tokyo, Toronto and Brazil all secured using IBM Z, as the company scales this service to global organizations.
Wait, There’s More: New Container Pricing
IBM also announced new Container Pricing for IBM Z, which provides simplified software pricing that combines flexible deployment with competitive economics.
IBM initially announced these three solutions:

• New applications for the deployment of new microservices and applications that enable clients to maximize the value from on-premises enterprise systems securely and in real time. Users can now colocate applications to optimize qualities of services that are priced competitively with public cloud and on-premises platforms.
• Application development and test with the freedom to substantially increase capacity of all development environments on z/OS to support latest DevOps tooling and processes. Customers can triple capacity with no increase in monthly license charge.
• Payment systems pricing based on the volume of payments a bank is processing, not the available capacity. Particularly in the fast-growing Instant Payment segment, this greatly increases flexibility to innovate affordably in a competitive environment. 


These container pricing options are designed to give clients the predictability they require for their businesses. It is scalable both within and across LPARs (logical partitions) and delivers enhanced metering, capping and billing capabilities. Container pricing for IBM Z is planned to be available by year-end 2017 and enabled in z/OS V2.2 and z/OS V2.3.
For more information, go here.

Beheer

Infrastructuur

Encryptie sleutelwoord nieuw IBM-mainframe

IBM onthult vandaag de z14, een nieuw mainframe gericht op beveiligde transacties

IBM z14 mainframe © IBM

17 juli 2017

Encryptie was de eigenschap die klanten bovenaan hun prioriteitenlijst hadden staan voor een nieuw mainframe, zegt IBM.
En encryptie is wat klanten krijgen. De nieuwste telg uit de z-Series mainframe-familie versleutelt alles op elk niveau van verwerking in het systeem: de database, de toepassingen, data die worden getransporteerd en de API's. De gegevens worden vervolgens opgeslagen in encrypted containers.

Het systeem is bovendien voorzien van meer beveiligingseigenschappen. Bijvoorbeeld, wanneer het systeem ontdekt dat er onregelmatigheden plaatsvinden die wijzen op een aanval zoals met malware, sluit het systeem zichzelf af. Ook al komen aanvallers door de eerste schillen van beveiliging heen, zal de sterke encryptie voorkomen dat ze iets met de data kunnen beginnen.

Bezorgdheid rond cyberoorlog

In de ontwerpfase van de z14 heeft de leiding van IBM's z-Systems-afdeling een tweejarig onderzoek gedaan onder 150 klanten om van hen te horen wat de belangrijkste behoeften waren met betrekking tot een nieuwe krachtpatser. Daarbij kwam de bezorgdheid over de cyberoorlog die zich voltrekt, als belangrijkste aspect naar boven. "Er zijn groepen met heel veel geld actief die uit zijn op data en er ook in slagen daar toegang toe te krijgen. Het is ons doel met de z14 hen te stoppen", zegt Ross Mauri, de general manager van z-Systems tegen TechCrunch.
Naast de aandacht voor beveiliging heeft IBM het nieuwe mainframe bovendien geoptimaliseerd voor het gebruik van machine-learning en business analytics om real-time inzicht te krijgen in de processen. Verder is het systeem geschikt om private clouds en blockchainprocessen te ondersteunen.

Nieuwe prijsmodellen

IBM introduceert bij de z14 ook nieuwe verkoopstrategieën in de vorm van Container Princing-modellen voor software:

• Microservices en application. Klanten kunnen hiermee colocatie van toepassingen inzetten om zo optimaal gebruik te maken van de quality of service tegen prijzen die vergelijkbaar zijn met die van public cloud-aanbiedingen.
• Application development and test. Voor testdoeleinden kunnen klanten de capaciteit van de ontwikkelomgeving op het z/OS verdrievoudigen zonder daar meer licentiekosten voor te betalen. 
• Payment Systems. Het gebruik kan worden afgerekend op basis van de transactievolumes in plaats van de beschikbare capaciteit.

Details van de werkelijke prijzen van deze prijsmodellen zijn nog niet bekend gemaakt, dus is het niet mogelijk te evalueren wat de term 'kosteneffectief' die IBM er op plakt precies inhoudt.

Lees meer over

http://agconnect.nl/artikel/encryptie-sleutelwoord-nieuw-ibm-mainframe?utm_source=nb_agc_20170717&utm_medium=email&utm_term=&utm_content=&utm_campaign=17-07-2017

ASCII Mandelbrot animation

Share this on Twitter, Facebook or Google+.

Published14 July 2017

Years ago, when I was programming in PL/1 on an OS/390 platform, I used some of the breaks for improving my PL/1 programming skills. One day I decided it would be fun to try to get an animated Mandelbrot fractal zoom working on a mainframe terminal. Recently I created a similar project for a Console application, which I will describe in this blog post.
Before we delve into the nitty gritty details of the code, first a small intro into the world of fractals.

Mandelbrot set

In mathematics, Fractals are abstract objects used to describe and simulate naturally occurring objects. Like the natural fern in the title image, artificially created fractals show similar patterns at increasingly small scales. Looking close at the fern leaf, it seems to consist of smaller copies of itself.
One of the most famous is the Mandelbrot set (see the image below), which was named after Benoit Mandelbrot

The Mandelbrot set can be explained with the equation zn+1=zn2+c$z_{n+1}=z{{}_n}^2+c$ . In that equation, c$c$ and z$z$ are complex numbers and n$n$ is zero or a positive integer (natural number). Starting with z0=0$z_0=0$ , c$c$ is in the Mandelbrot set if the absolute value of zn$z_n$ never becomes larger than a certain number (that number depends on c$c$ ), no matter how large n$n$ gets.
Images are created by applying the equation to each pixel in an iterative process, using the pixel's position in the image for the number 'c$c$ '. 'c$c$ ' is obtained by mapping the position of the pixel in the image relative to the position of the point on the complex plane.
More iterations per pixel will take longer to process, but yield a fractal pattern with a higher detail. The animation below shows the Mandelbrot set based on a static number of iterations per pixel:

Programming the OS/390

Getting animations to work on a terminal system which requires a server round-trip for each displayed page, is not an easy task; especially when ASCII-characters are the only means of drawing available. In fact, the only way to do it, is to cheat a bit.
The solution was to convert the calculated Mandelbrot output to corresponding ASCII-shades and store them in a file. In this file each X amount of lines provided a full frame of the animation for a terminal window with a height of X rows. Animating was as simple as scrolling through the file page-by-page.

This inspired me to create a similar solution inside a Windows console application.

Console application

For a console application, the approach is similar in the sense that we use ASCII-character to represent the shading of the fractal. However, no server round-trip is required and we can output directly to the screen.
The 'pages' are calculated on a row-per-row basis and as soon as a full frame is calculated, the entire buffer is written to the console window for display. After this, the new zoom-factor is determined and the next page is calculated.
In pseudo-code of this main loop is as follows:

while (we did not reach the maximum Zoomfactor)
{
    // Calculate the y-coordinates involved in the current zoom Factor

    // For each of these y-coordinates, calculate the entire row and add it to the frame

    // Clear the console window and draw the calculated frame

    // Recalculate the Zoomfactor
}

The real magic happens when calculating the contents of each row, which can be done in parallel, making the processing time significantly shorter.
In pseudo-code calculating a row looks as follows:

// Determine the x-coordinates to calculate

// For each x,y-coordinate do the following:
//      Calculate the c-value for that coordinate
//        Determine the ASCII-shade for that value

// Return the row

Main loop

Let's take a look at the code for the main loop. Note that this C# code is not fully optimized in order to keep the code in one single method.

private static void DrawFractal()  
{
    const double StopfactorZoom = 0.00000000000005; // At this zoom-factor we stop
    const double StopfactorShr = 0.7496494959997;   // Higher number = to the right, Lower = to the left
    const double StopfactorShu = 0.03000094443895;  // Higher number = Down, Lower = up
    const double ZoomSpeed = 0.85;                  // Between 0 and 1: zoom in, > 1: Zoom out
    const double YCenter = 0.95;                    
    const double YStep = 0.5;

    var zoomFactor = 0.9;
    var yLines = Console.WindowHeight - 2;

    var yMin = YCenter - (yLines / 2f) * YStep;
    var yMax = YCenter + (yLines / 2f) * YStep;

    while (zoomFactor > StopfactorZoom)
    {
        // Calculate the y-coordinates involved in the current zoom Factor
        var shiftRight = zoomFactor > StopfactorShr ? zoomFactor / ZoomSpeed : StopfactorShr;
        var shiftUp = zoomFactor > StopfactorShu ? zoomFactor / ZoomSpeed : StopfactorShu;

        var yCoords = new List();
        for (var y = yMax * zoomFactor - shiftUp; y >= yMin * zoomFactor - shiftUp; y -= YStep * zoomFactor)
        {
            yCoords.Add(y);
        }

        // For each of these y-coordinates, calculate the entire row and add it to the frame
        var grid = new string[yCoords.Count];
        var tempFactor = zoomFactor;
        Parallel.For(0, yCoords.Count - 1, i => 
        { 
            grid[i] = CalculateRow(yCoords[i], tempFactor, shiftRight); 
        });

        // Clear the console window and draw the calculated frame
        Console.Clear();
        foreach (var line in grid)
        {
            Console.WriteLine(line);
        }

        // Recalculate the Zoomfactor
        zoomFactor = zoomFactor * ZoomSpeed;
    }
}

• Lines 3 - 8 are constants that determine the Y coordinate for the center of the zoom, the zoom speed and when to stop animating. Without the stop-condition, the animation would play until eternity.
• Line 13 - 26 determine the y-coordinates that are involved in the current zoom level. These are redetermined for each zoom-action.
• Line 29 defines the grid in which each row will be stored. A row is a string of ASCII-characters representing the shades of the coordinates on that row.
• In lines 30 - 34 all x-coordinates are calculated for the given y-coordinate, resulting in a row (string), which is stored in the grid in line 33.
• Lines 37 - 41 reset the console window and output the grid to screen in a row-by-row fashion.

This is pretty straight forward. The most important line to notice, is line 33, where the specific rows is calculated. Let's see what this CalculateRow method looks like.

CalculateRow

private static string CalculateRow(double y, double factor, double shiftRight)  
{
    const double XCenter = -0.45;
    const double XStep = 0.3;
    const int MaxIterations = 50;

    var shades = new[] { ' ', '\u2591', '\u2592', '\u2593', '\u2588', '\u2593', '\u2592', '\u2591' };

    var xLines = Console.WindowWidth - 2;
    var xMin = XCenter - xLines / 2f * XStep;
    var xMax = XCenter + xLines / 2f * XStep;

    var xCoords = new List();

    // Determine X-coordinates to calculate
    for (var x = xMin * factor + shiftRight; x <= xMax * factor + shiftRight; x += XStep * factor)
    {
        xCoords.Add(x);
    }

    var row = new char[xCoords.Count];

    Parallel.For(0, xCoords.Count - 1, i =>
    {
        // Calculate the mandelbrot-value for the x,y-coordinate    
        var x = xCoords[i];
        var iterations = 0;
        var xTemp = x;
        var yTemp = y;
        var arg = Math.Pow(x, 2) + Math.Pow(y, 2);

        while (arg < shades.Length && iterations < shades.Length * MaxIterations)
        {
            var xSqr = Math.Pow(xTemp, 2);
            var ySqr = Math.Pow(yTemp, 2);

            yTemp = 2 * xTemp * yTemp - y;
            xTemp = xSqr - ySqr - x;

            arg = xSqr + ySqr;
            iterations++;
        }

        //Determine the ASCII-shade for that value
        row[i] = shades[iterations % shades.Length];
    });

    return new string(row);
}

Some highlights:

• Lines 3-5 are the constants that determine the zoom parameters for the X-coordinate and the maximum number of iterations for each pixel (see the previous paragraph on the Mandelbrot set).
• Line 7 is the character-set for the ASCII shades in Unicode. Note that this list is circular (not palindromic since the space is not present at the end) to allow a modular approach when determining the correct shade for a given value.
• Lines 9 - 19 determine the x-coordinates that are involved in the current zoom level analogous to the y-coordinates in the main loop.
• Line 23 makes sure that each x-coordinate in the row is processed in parallel.
• Lines 32 - 42 calculate the c-value for the specific x/y-coordinate limited by the maximum number of iterations.
• In line 45 the ASCII-shade for the calculated c-value is determined.

Copy paste the main-loop and the CalculateRow() method in your own console application and start tweaking the code yourself to see what happens.
If all goes well, the first few frames of your animation should look like this:

Practicing your programming skills may not always be about writing great code, but rather finding fun challenges and puzzles to conquer. I'm always curious to know which ones other people came up with, so let me know in the comments below!

Development C# Mathematics

Coen Goedegebure

https://www.coengoedegebure.com/ascii-mandelbrot-animation/

Jefferies gives IBM Watson a Wall Street reality check

Posted 21 hours ago by John Mannes (@JohnMannes

Net Neutrality Day of Action spurs millions to speak out for online freedoms

 

IBM’s Watson unit is receiving heat today in the form of a scathing equity research report from Jefferies’ James Kisner. The group believes that IBM’s investment into Watson will struggle to return value to shareholders. In recent years, IBM has increasingly leaned on Watson as one of its core growth units — a unit that sits as a proxy for projecting IBM’s future value.

In the early days, IBM’s competitive advantage was its longstanding relationships with Fortune 500 companies. IBM Watson effectively operates as a consultancy where the company engages in high-value contracts with corporates to implement Watson technology for specific business cases. Unfortunately, IBM is struggling to bridge the gap between client needs and its own technological capability.
Jefferies pulls from an audit of a partnership between IBM Watson and MD Anderson as a case study for IBM’s broader problems scaling Watson. MD Anderson cut its ties with IBM after wasting $60 million on a Watson project that was ultimately deemed, “not ready for human investigational or clinical use.”
The MD Anderson nightmare doesn’t stand on its own. I regularly hear from startup founders in the AI space that their own financial services and biotech clients have had similar experiences working with IBM.
The narrative isn’t the product of any single malfunction, but rather the result of overhyped marketing, deficiencies in operating with deep learning and GPUs and intensive data preparation demands.

Jobs data collected by Jefferies using Monster.com data

If job postings are any indication, IBM is not keeping pace with other technology companies in hiring machine learning developers. Things seem particularly lifeless in the field of deep learning, where IBM’s hiring appears anemic with respect to Apple and Amazon — and let’s be real, things would look much worse if Google, Microsoft and Facebook were added to this table.
The information provided in Jefferies’ report isn’t new nor groundbreaking, but it’s a strong signal that Wall Street is beginning to pay more close attention to the challenges facing IBM Watson. I’ve listened to my fair share of IBM earnings calls and it’s clear the market has been focusing too heavily on short-run growth and not enough on long-term technological or strategic sustainability.
It seems perfectly reasonable that IBM shot out of the gates like a rocket in a mostly sterile AI market selling to CTOs and newly minted chief data officers with just enough anxiety to open check books. But the reality is that AI isn’t an amorphous black hole that sucks in unstructured data to produce insights. A solid data pipeline and a domain-specific understanding of the AI business problem at hand is table minimum.
Coasting on early success won’t cut it in today’s AI-first world where machine learning platforms are a dime a dozen and tech giants like Google and Amazon are throwing billions into their respective cloud ecosystems.

Modernizing Mainframe Applications: Great Job Opportunities

by Denise P. Kalm  on July 10th

I started my career writing macro-level Assembler code to run under CICS. We would carry our carefully edited coding sheets over to a small set of dumb terminals at our appointed hour. Efficient typing was a must, as we had to share these terminals.
PCs replaced dumb terminals and coding sheets have gone the way of carbon paper. But today, many of the techniques developers opt for aren’t much more advanced than the ones we used in the 80’s. This limits how well the mainframe can play in the 21st century.
COBOL was created in 1959. Designed to run on more than one kind of mainframe, it still powers 70 percent of business and transaction systems, and 90 percent of financial transactions. That means billions of transactions are depending on the reliability, maintainability and adaptability of a language that is more than 50 years old.
Yet languages like COBOL can take time to learn. To write efficient, optimized code quickly is a skill that may take years to develop. Back in the 80’s, we were allowed a year or two to code a new application; businesses can no longer wait that long to offer customers the new functionality they demand. The standard method of developing code is just too inefficient. There are several approaches that offer a better path.
One of these is Architected Rapid Application Development (ARAD). Become an expert in this area. Learn how to exploit the software that writes much of the code for you through frameworks and patterns. ARAD is a smart version of object-oriented design which works well with Agile development methodologies. The result is faster turnaround on application requests using code that has already proven itself to perform well. ARAD just makes smart people smarter and more efficient and the training "bar" is low.
Software vendors provide great ARAD tools which are essentially code bases. Reusable code segments, such as GUIs, can be easily rendered by even the greenest developers. But what makes these tools so great, beyond speeding development, is that they offer the ability to modernize code where you felt no modernization was possible.
When you can respond to requests for code modification and even new programs quickly, you help to ensure that the mainframe will continue to have a robust presence in your data center. Check out this option. Mainframe development is still a great job opportunity.