The waiting has an end

We all experience it many times every single day. With italian cars that just won’t start in the morning. With Exchange Calendar appointments that simply disappear. With mobile apps that just won’t connect to the Internet when we need them. With auto-correct features in email clients that changed some words in your email in a career-bending or relationship-ending fashion without you noticing before you pressed the send button.

What I refer to is the bitchy randomness at which technology failures light up our days. Light up in flames. And like with all things people love from the “consumer space”, the expectations rise also towards the so-called “enterprise space” to follow accordingly. That’s commonly referred to as “consumerization of IT“.

Over the past months and years, we got painfully aware that even in ABAP the developer community has become comfortable with the status quo, complacent almost as to how easy and predictable it is to quickly code a new application to serve your employer’s or contractor’s needs. Far too easy, we believe. We all feel that it has to remain a certain science, wizardry, black magic to understand how a computer program actually works. And it has to feel arbitrary to some extent. Like bringing up your kids.

My team got notice of this burning issue already some months ago, but it took us a while to build up the necessary sense of urgency around it. And luckily, with Design Thinking, we got the tools at hand to really confront the problem heads-on. How could we bring the random malice of the consumer space experience to enterprise computing? What we came up with is simple but effective. As always.

After building and pushing around a fancy straw prototype of the solution in a Design Thinking session, we decided to introduce the COME FROM statement in ABAP. It contrasts with the GOTO statement, which for good reason has been considered as an approach too naive to effectively confuse programmers by acclaimed computer science legend Edsger W. Dijkstra already in 1968, as it does not impact the control flow of a program by telling where to jump to in execution, but rather tells where to come from whenever program execution happens to pass the given source code location. It started as a notion, but we quickly turned it into an ingenious idea and then into a brilliant concept. In particular if one looks at the additional attributes that one can add to the “come from” statement:

COME FROM [WITH PROBABILITY <expression> ].
where <expression> can be any valid ABAP expression yielding a floating point value between 0 and 1, or whatever else at which the execution is not determined at all.

As common sense implies, the COME FROM statement will be executed with the given probability, resulting in the programm execution continuing in the first statement following the COME FROM statement or continuing at the statement at the <source code location>.

Without thinking for too long, even the most junior developer will realize what enormous excitement such statements can bring to otherwise trivially boring code.

In a relentless effort to bring unnecessary reduncancy into the set of ABAP language features, we have also decided to introduce a new statement for execution blocks:

SKIP. <statements> END SKIP [WITH PROBABILITY <expression>].

The careful observer will have recognized our villainous brilliance to move the probability expression to the end of the SKIP execution block in order to further reduce code readability.

We plan to introduce these new ABAP language features with SAP NetWeaver 7.4 after some more intensive validation with customers.

With SAP NetWeaver 7.5 we will then provide a set of new capabilities in the ABAP development tools to improve the effectiveness of the new statements above.
First, we will introduce what we call “progressive obscurity” in the “ABAP for Eclipse” editor: with this feature you can — based on personalization of your Eclipse settings — determine whether the editor shows or hides the SKIP and COME FROM statements from display. This adds enormously to the fun during professional code review sessions. We are also testing whether randomly hiding normal statements outside of SKIP blocks could further help to confuse code reviewers.
Second, we will add support for the above statements in the ABAP Debugger and the ABAP profiler, which will be enhanced with predictive code execution capabilities built right into the tools themselves interfering with the underlying runtime Virtual Machines.

We are also working on bringing the above concepts into other programming languages: River Definition Language (RDL) is a natural candidate of choice. But also for Java we are pushing a proposal into the Java Community Process (RCP) to embed these capabilities into Java 8. For C/C++ we have started discussions with the ANSI committee. The ECMA committee has been approached by us to embed the concepts into ECMAScript/JavaScript and the major browser vendors have been invited already to a workshop in Walldorf. If we do something, we do it right.

Obviously, all of this is only a stop gap solution to bridge the time until the probabilistic behavior has been pushed further down the stack into the hardware itself. We have started to try to convince major CPU/MPU builders like Intel and AMD to add the above features to their hardware designs yielding utmost performance in randomness.

We understand that such a hardware driven approach will take some time to be ubiquitously available in all IT landscapes. We have therefore triggered efforts with Operating System makers to provide software solutions to the market that already today bring the benefits of random behaviour to end users. Solutions include TCP/IP drivers, DNS and DHCP servers, network domain login modules, Exchange server modules and file system drivers that will show arbitrary failure and outage behavior.

A renowned IT analyst company, that wants to remain unnamed for unspecified reason, has estimated the 2017 market for such solutions to exceed 37 billion US$ in total. While we consider the market significant, we have certain concerns though how much of this market we can actually tap into with a standard software solution, as corporate IT departments already today seem to have deployed partial solutions for random infrastructure behavior. At least that’s what we deducted from end user reports we’ve evaluated.

Patents are of course pending.

Hope is at the horizon. The days of waiting are numbered. With probability 0.5.

All will be fine

5 Comments

  1. I have reason to believe that the processes used to implement the WITH PROBABILITY clause may infringe on my patent for the MAYBE statement. Please provide an address where my lawyers (L’iar DeShonk) can serve the necessary papers.

    1. COME FROM … [WITH PROPHECY] is really a great concept 😉

      I only meant things like code reviews with peer programmers etc. in general. We do those at SAP as one Q measure as well. But there is no dedicated “initiative”. It’s normal software engineering practice.

  2. So, you guys left out one of the best features : STOP . This behaves better than any EXIT command and using the parameter IN T(s) adds the historically proven effect of divine intervention. EXIT is always local, but STOP could behave locally or globally or even better recursively across the complete calling stack. For this we add parameter SCOPE.

    simply put : STOP IN t SCOPE x.
    of for the joy of debugging: STOP in RANDOMTIME() SCOPE GLOBAL.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s