Extreme Programming For Platform Software

I'm unconvinced of ExtremeProgramming's utility when it comes to the design and construction of platforms for other software (e.g. programming languages, frameworks, message protocols, library APIs, operating systems, security models, concurrency models, etc.) - too often, the need to maintain backwards compatibility, especially to support the 'quirks' and 'bugs' of previous modes, quickly becomes an enormous burden against any attempt to RefactorMercilessly. However, I think it works fine for situations where the programmers DO possess full authority to muck around with all code and repair any dependencies broken as a consequence of refactoring. BigDesignUpFront vs YagNi, ProgramInTheFutureTense vs DoTheSimplestThingThatCouldPossiblyWork - I believe that each have their place in design and construction of software.

What if you codify those backwards compatibility 'quirks' and 'bugs' as automated acceptance tests? Then, the programmers will automatically continue to support the quirky interface. When the programmers want to change the interface, they submit a new story. The customer either schedules it for implementation or not, depending on his needs.

Ah, so your answer is: "That's not a bug! That's a feature!" And it isn't just 'quirky interface', it's 'buggy consequences' for a 'correct' interface. E.g. consider a major vendor's web browser handling pixel placements - if stuff was off by, say, 7 pixels, then people start adding 7 pixels to reach their intended offset. And now you need to maintain this bug. You even put it into your acceptance tests. This is especially evil if the interface is specified by a standard somewhere. OTOH, if your goal is vendor lockin, you're well on your way to accomplishing that. Combine this with a simple deprecation strategy -- automatically warn developers (both yours and your customer's) when they use a deprecated interface -- and the project would likely evolve into a "clean core", a "clean interface", and a "quirky deprecated interface". At some point, it may become apparent that it's time to document the "clean interface", drop some or all of the "quirky deprecated interface", and announce version 2.0.

Deprecation often sounds neat in theory but (given any sufficiently large user-base) it rarely works in practice, mostly because blaming the users for not forcing you to fix your bugs doesn't often work in practice. About the only thing you can do is upgrade versions entirely and either (a) hope you won't need to change again for a long time, or (b) provide an explicit mechanism to extend your own interface and maintain versioning compatibility directly into the project/language/framework/etc.. The latter option is not the most simplistic thing possible, and certainly requires a little BDUF, but can be quite simple and very elegant - I've seen it in some C and C++ libraries/frameworks (OneMoreLevelOfIndirection - e.g. asking for function-pointers by version-number and name), and I've seen it for various syntax systems (<?xml version="1.0"?>, syn, etc.), but even here the older interfaces remain 'baggage' that you can't eliminate and for which you probably ought maintain tests. Of course. That's what I suggest in the first place.

Seeking a 'good enough' refactored interface by use of throwing old ones away gets you to a decent position after a few or several versions (depending on the complexity of the product). However, the need to avoid breaking things never quite goes away - it always remains a constraint forcing you to take great care at the edges of your project whenever you feel the urge to RefactorMercilessly. That makes it rather difficult to be 'merciless'.

Claims by someone:
It should be known that platform is a BuzzWord for "a bunch of stuff" like.. everything, and everything. The term is so overloaded it doesn't have any meaning any more. This page should rather be called ExtremeProgrammingSucks? or ExtremeProgrammingDiscussion? or ExtremeProgrammingDebate?.

Ah, it is Mr. EverythingIsa BuzzWord again.

No, platform has a specific meaning as I use it here: a software platform product is one intended for other users to interface with via construction of code that interfaces with the platform. The key word there is the 'other' in the 'other people' - as in, the platform itself is what you are selling. And GUIs don't count because, while they are interfaces, they aren't platforms for software. However, language standards and implementations do count - e.g. C language is a software platform; indeed, they might qualify as the 'pure' example since that's the only thing they do: accept code to run. But such things as frameworks (like Java Swing or MFC or readline) are also prototypical. Extensible and plugin systems like Mozilla Firefox and GIMP aren't quite as prototypical because they offer considerable initial user functionality, but they do qualify - at least for the interface they expose for these plugins and extensions. The basic consequence of software platforms is that their interfaces are basically impossible to refactor while keeping the software-platform customers happy (because a programmer whose code breaks is a very angry customer). You can add to the interfaces monotonically, but you can't perform any reductions or transformations. And adding to an interface is not at all the same as refactoring.

And as far as your page suggestions go: I'd have chosen 'ExtremeProgrammingNotForSoftwarePlatforms?'. I've used XPs tenets in other places, though, and must admit to some satisfaction with them. But, now that I think about it, it seems likely that ExtremeProgrammingNotForSoftwarePlatforms? is just a specific case of XP not really being for negatively stated constraints in general. I.e. "must never take more than N milliseconds to accomplish task X", "must never allocate memory from the free store after loading", "must never give my personal information to an unauthorized person",... "must not violate backwards compatibility" - backwards compatibility is, itself, a UserAntiStory.

Eclipse IDE is a platform, Mozilla is a platform, this wiki is a platform, Win32 is a platform, Ebay is a buyer/seller platform, C2 is a discussion and article platform, etc.

True. And you can't just muck around with certain parts of Eclipse or Mozilla or Win32 without breaking a lot of other people's code. But this wiki is not a software platform product - all the code (pages) on the wiki are owned by the wiki, and transformations are easily possible.

Since this wiki (c2) was written bottom up with extreme programming ideas in mind (bottom up content, do the simplest thing, etc) and since this wiki is a platform for lots of people... and since everything else including Emacs, EditPlus, and Internet Explorer are platforms - I call the day. I call BullshitBingo.

That's an invalid argument - premature generalization and assuming the antecedent. I wonder if there's a penalty for calling bingo without actually having it.

Your claims seem to be Extreme Programming cannot create platforms well... C2 wiki is a platform and it works. So extreme programming can work for creating platforms. Anyway, I'm no huge fan of extreme programming, but since this wiki was written by extreme programmers I have to have some respect.

C2 is not a software platform product. Your argument that "everything" is a platform for software is fallacious.

Your argument that C2 is not a software platform is fallacious. C2 is a platform for tens, hundreds, or thousands of people and software browsers/editors to connect to and utilize.

Which is, of course, entirely irrelevant. People aren't writing software to run on C2, therefore C2 is not a software platform. HTML is a software platform. HTTP is a software platform. C2 is not. Platform for people != Platform for software. Browser software connects to the C2 platform daily. C2 software is a surface and platform that serves people and other software (robots) text and data daily. C2 wiki is a surface and platform that can support hundreds of users running browser software. C2 platform has common platform rules and tools in the platform (such as syntax for wiki articles, find tools, url API, "diff" toolset, steward tools). A C2 wiki contains a framework, platform, base, in which humans reuse daily. Many web applications are platforms since they have a URL api and a common surface which people and software can connect to. Ebay can be considered a buyer and seller platform for people and software. C2 can be considered an article, discussion, and publishing software platform that runs in a web browser for web users and software. Platform platform platform. Ebay is a software platform that people can connect programs to. Every website could be described as a platform - with some being bigger platforms than others. An operating system could even be described as a people platform more so than a software platform - since mostly an operating system serves people. A CPU could be described as a platform which software runs. A browser could be described as a TCP/IP platform. Platform Platform Platform. Whatever a platform is.
XP can be very confusing when writing platform software if you're not careful. Let's take the specific example of an API. If you're using XP to write an API, then: It's less confusing when writing something like a financial package or a fluid dynamics simulator, because it's obvious that the CPA or areonautical engineer aren't the developers. Here, where the customer has similar skills, the temptation is to have the customer be a developer.

View edit of December 11, 2012 or FindPage with title or text search