Chapters (57)
- Cover Page
- Title Page
- Dedication
- ONE
- Chapter 2
- Chapter 3
- Chapter 4
- Chapter 5
- Chapter 6
- Chapter 7
- Chapter 8
- Chapter 9
- Chapter 10
- Chapter 11
- Chapter 12
- Chapter 13
- Chapter 14
- Chapter 15
- Chapter 16
- TWO
- Chapter 18
- Chapter 19
- Chapter 20
- Chapter 21
- Chapter 22
- Chapter 23
- Chapter 24
- Chapter 25
- Chapter 26
- Chapter 27
- Chapter 28
- Chapter 29
- Chapter 30
- Chapter 31
- Chapter 32
- Chapter 33
- Chapter 34
- Chapter 35
- Chapter 36
- THREE
- Chapter 38
- Chapter 39
- Chapter 40
- Chapter 41
- Chapter 42
- Chapter 43
- Chapter 44
- Chapter 45
- Chapter 46
- Chapter 47
- Chapter 48
- FOUR
- Chapter 50
- Chapter 51
- Chapter 52
- Other Books By This Author
- Copyright
In my last year I traipsed around the milk round of potential employers, trying to find something that would plug into that interest in mathematical logic. I found it in software development—which brings a wry smile to the lips of all my acquaintances who have ever found themselves staring at a blue screen with a baffling error message.
But software ought to be logical. The math underlying relational databases, for instance, accessed by virtually every Internet user every day, is pure and beautiful. There is a whole discipline called “formal methods” in which you set out what you want to achieve and write a program that is a self-proof that it will do exactly what it’s supposed to do.
That was the dream, as I began my career—first in Manchester, and then, inevitably, in London, the center of everything in Britain. When I could afford it I took a small flat in Hackney, and started a gruesome daily traveling routine by bus and Tube. But as I started work, first in the software development departments of large corporations and then in independent development houses, I soon found that rigor was expensive—less so than the cost of fixing all the bugs later, but an upfront cost virtually nobody was willing to pay.
Eventually I drifted into testing, the one place where you are supposed to be rigorous. For a while I prospered. The fashion was for development methods that were, if not formal, at least structured and so open to inspection. I would draw up my test plans covering every conceivable condition the software could take, with predictions of how it should react. I turned up errors at every level from typos in the code to compilation into machine code to fundamental design flaws—but that was okay; that was the job, and it was satisfying to make things better.
But there was a constant pressure to cut costs on testing, which higher-level managers could never quite figure the benefit of, and endless turf wars between competing teams of developers and the testers come to rip to pieces “their” code. I started to be bypassed by development managers who could boast they were delivering something of direct benefit to the end user—and who, unlike me, had significant budgets and teams to run.
Not only that, they were all tall men. It’s always tall men who get on in management hierarchies, no doubt some deep primate thing. I’m a man but was never that tall, so was stuffed from the start. My trace of a Manchester accent didn’t help, either.