22 July 2001, 23:51 GMT
"Several Million Newsgroup Messages a Day..."
Visual Basic programmer Vikram Stealth is over the moon from the almost hysterically positive reception that his new development methodology has been given. Reactive Programming, or RiP, has been astonishingly well received by a phenomenal number of software companies.
Several newsgroups devoted to RiP receive millions of messages per day. In just three months, over two hundred books have been written on RiP, and several thousand websites offer ridiculously expensive training courses. Somewhat puzzled by this overnight world domination, we arranged a telephone interview with Mr Stealth. And this is the result...
First of all, we asked Stealth if he had genuinely expected this sort of response.
"I never expected anything like this," he exclaimed excitedly. "It's like world-wide mania. Many project managers have decided to mandate use of my methodology without even knowing what it involves! I even saw on one company website, they boasted that their policy was always to use my methodology, even before I had released any information on it! I mean, you couldn't make something like that up."
So what course of events lead up to Vikram's astonishing success with Reactive Programming?
"A couple of years back, I tried extreme programming or XP," explained Stealth, "but it just wasn't extreme enough." In his spare time, Vikram enjoys snow-boarding, base jumping and skydiving. "Not the real sort," he clarified hastilly. "That would be dangerous!"
So what exactly is this new methodology he has invented?
"Well, I've been involved in so many projects that simply evolved, without any clear direction or anything, that I began to wonder if maybe there was a way to capture this process in a formal methodology. And so Reactive Programming was born."
We asked Vikram what his process involves.
"Well, it represents an entire new paradigm in software development. It will revolutionise the way companies do business, and dramatically decrease time to market. Risky projects with dynamic requirements are perfect for RiP."
So we asked him again.
"Okay, okay. In a nutshell, you just go at it hammer and tongs, throwing everything and the kitchen sink into your program. The point is, at this stage you don't care what the program structure is. There's no point even thinking about an overall architecture either - it's all going to change, so it really doesn't matter."
And then what?
"After that? Well, you just keep on programming until you are almost dead from exhaustion, or until the pizzas arrive (whichever comes first). And then you pause, take stock, munch your pizza, and start to think about what the customer might actually want from this project. For example, do they want an accounting system? Or are they really after an on-line parts ordering system? Chances are, you will have written some portion of what they want during your frenzied blind coding session earlier on. So you pick out the bits that you need, put comments around them like /* Good! Keep this bit */ and of course keep the rest just in case it comes in useful later on. You never know what you're going to need, so you must retain the whole lot, just in case. And try to keep everything in one file, so you can get at it more easily."
But isn't what you just described hacking?
"A World of lazy fuckwit so-called professionals"
"Absolutely not. This part of the process is actually known as the Transmogrification Phase - or 'Apply and Adapt', to use its less formal moniker. It's a vital and fundamental part of Reactive Programming; turns the whole 'hacking' fallacy on its head. Later, when you're doing really advanced RiP, you can get several programmers around the same PC, all trying to hit the keyboard at the same time. It might be chaotic if they get it wrong, but if they're all accomplished RiP'ers, the process becomes something quite amazing and transcendental: it's no longer programming as we mortals know it, but a sort of ethereal magic. Frankly, we're just starting to discover the almost limitless potential that RiP offers."
That's nice. So does the customer have any involvement at any stage?
"Well, sure, this stage might actually involving picking up the phone and speaking to the customer. Depends on the scope of the project."
But surely you won't know the scope until you have spoken to the customer?
"Project Mission Statement"
"Ahah-hah, that really is the beauty of this approach. Because the project is essentially reaction-based, it is self-defining. The process involves constantly redefining the purpose of the project - you may like to produce a project mission statement, or simply wing it. It really doesn't matter. But the point is, you can't possibly know the scope until the project is finished. Therefore, there's rarely any point even speaking to the customer until
right at the very end."
Okaay, so you've done your blind coding, you've phoned the customer (or not) and you've gone back through your code, applying some parts and commenting others. What comes next?
"The beauty of Reactive Programming is its cyclicity. All you do now is go back to the Blind Coding stage. It's useful to try and forget as much as possible about what the customer may have said to you. Don't let facts and requirements cloud your mind: keep your programming pure. If Reactive projects have failed, 90% of the time it's because the programmers forgot this one vital element: do not, under any circumstances, listen to the customer. They don't really know what it is they want. It's your job to educate them!"
So if the customer says they want an e-procurement system?
"Give them an on-line drinks dispenser instead! They'll thank you for it. No one really knows (or cares) what an e-procurement system is anyway. Least of all the customer."
And when does the process end?
"That's really the beauty of this method. See, it never ends! It's entirely cyclical. You end up with a system that doesn't work, and is nothing like what the customer may have "wanted". So, essentially, with this one project you've got yourself a job for life!"
Your critics have suggested that RiP's success is simply down to the fact that it lets developers do what they're already doing, i.e. act like complete know-nothing cowboys, and simply formalises the process so they can feel better about their inevitable failure.
"And your point would be..?"
Vikram Stealth's book, "Reactive Programming: The e-Gravy Train" will not be published, price $34.99.
Stages of Reactive Programming:
- Blind coding - a frenzied attack at the long-suffering keyboard. Involves much mouse clicking,
not moving anything except your hands for several hours at a time, just churning out any old
code that comes into your mind. Randomness is the key here. And great ideas - custom screensavers,
proprietary email, that sort of thing.
- Pause, Munch Pizza, Contemplate: Optionally, phone (or email) the customer and ask what they want.
- Apply and adapt (Transmogrification Phase) - mix things around a bit; do lots of cutting & pasting; deleting and partial rewriting, e.g. turn a quicksort algorithm into a postcode validator.
- Back to stage 1.
Elsewhere: Related Sites and Things: