It’s July 17, 2017. Happy New Mainframe Day, everyone!

Like clockwork, at about 12:01 a.m. New York time, IBM issued this press release to kick off New Mainframe Day. I’ll have more details and comments to offer in due course. In the meantime, it’s clear what IBM is emphasizing: security. The new IBM z14 is designed to encrypt everything, all the time, in multi-layered fashion. The world is far more dangerous than ever, with businesses (and arguably even some governments) literally dying because of security breaches. This new machine hugely helps.

If you have a mainframe, fantastic! Please keep it current. Use it more effectively and more fully to protect your business (or government) from current and emerging threats. ┬áPut your mainframe in full charge of protecting your organization’s vital information and associated information services. And get on board the IBM z14 as soon as you can.

If you don’t have a mainframe, now’s the time to take a fresh look if you want to survive. That might be a mainframe in the cloud (such as IBM’s High Security Business Network for Blockchain) or in a hybrid cloud deployment. Either way, IBM Z is a big part of the answer to the world’s information security calamities.

There are a couple speed bumps on the computing horizon: the years 2038 and 2042. Specifically, January 19, 2038, and September 17, 2042 (UTC dates). How dangerous these speed bumps will be depends on you, dear Millennial Mainframers. Maybe your parents had fun (or “fun”) getting ready for Y2K. Now it’s your turn to help keep the modern world modern.

The 2038 problem is rooted in the classic UNIX time epoch. UNIX and UNIX-like operating systems, and more than a few UNIX-influenced programmers, decided to represent time in the form of a 32-bit signed integer. This integer (time_t) expresses the number of seconds since 00:00:00 UTC on January 1, 1970. (Bell Labs gave birth to UNIX close to that date, and 32 bits seemed like enough back then.) Negative integers are allowed and represent times and dates before 1970. That 32-bit signed integer can represent time up through and including 03:14:07 UTC on January 19, 2038. After that, the 32-bit time_t will wrap around to a negative value representing the very early part of the 20th century. Which won’t be so much fun in 2038, of course.

The 2042 problem is conceptually similar but is, as far as I know, unique to IBM mainframes. In that case a 64-bit unsigned integer counting the number of 2-12 microseconds since January 1, 1900, will wrap.

These two problems are quite close together chronologically, so you ought to view them as two parts of the same basic problem. Fortunately, the 2042 problem should be easier to avoid. IBM expanded the time of day clock in mainframe hardware starting with the Generation 6 ESA/390 processors first introduced nearly 20 years ago. That means every 64-bit IBM mainframe also includes the expanded TOD clock at the system level. There is still some software, including operating system software, that only “sees” the 64-bit fragment of the expanded TOD integer. That’s now changing, so all you should need to do in terms of operating systems and middleware is to stay at least relatively current in your operating system and middleware release levels. Then you simply check code, such as tools and applications, to make sure they also “see” beyond the 64-bit TOD value. IBM has some tools that can help you identify TOD-challenged code, such as this one.

The “bigger fish” is the 2038 problem. UNIX and the classic UNIX time format have spread practically everywhere, and they keep spreading, mostly in the form of the 32-bit Linux kernel on other architectures that are popular for embedded devices. In 2013 the OpenBSD community decided to break strict compatibility and expanded time_t to 64 bits in that operating system. NetBSD took a slightly different approach, preserving compatibility with existing binaries that expect a 32-bit time_t but not allowing any new binary compilations except with a 64-bit time_t value. The Linux kernel is still a work in progress but will likely adopt a similar approach to NetBSD. And that’s just at the operating system level. There is undoubtedly a lot of middleware, tool, and application code inspired by or derived from UNIX (and UNIX-like projects) that adopted the heritage UNIX time format.

The 64-bit Linux kernel uses a 64-bit time_t value, so 64-bit Linux distributions should be safe as far as the operating system goes. The Linux community discontinued support for 31-bit Linux kernels on IBM z Systems and LinuxONE servers a couple years ago, and now only the 64-bit kernels are available. As long as you retire any residual 31-bit Linux instances before 2038, preferably well before, you should be OK from an operating system point of view.

z/OS is a fully certified UNIXTM operating system, but again as long as you stay at least reasonably current you should have no operating system-level problems. You’ll still have due diligence to perform on other code (middleware, applications, tools, etc.) It’s the same with other operating systems (z/VM, z/TPF, z/VSE, etc.)

Unlike the Year 2000 problem, the 2038 and 2042 problems probably will not cause many difficulties before the wraps actually happen. That’s both good news and bad news. The good news is that there shouldn’t be much breakage until then. There’s a lot of bad news: the risk of complacency, the near simultaneous onset of any breakages, and the world’s progressively greater dependence on computing technologies that might break.

I wish you all the best of luck in keeping the world running smoothly.