-Lets start with a small meditation, because Complete Programming (CP) relies on
+Lets start with a small meditation, because Complete Programming (CP) relies on
embodying a mindset that is still a bit alien to some. In one word it is holistic -
meaning seeing the full picture. That includes the users view, programmers view
and project managers view. Maybe even the designers view. That sounds demanding,
but you do it already when you really care about something.
-As a consequence we count an ugly icon, missing documentation or an badly designed
-internal API equally as a bug as a crashing function. CP is desinged to deliver
-that high standard, without packing too much burden on the programer. Our
-development models knows several decoupled, well defined stages - so we only care
-about one goal at a time. Additionally we reduce duplicate work and duplicate data
-where possible and enforcing the quality of communication and self reflection.
-For instance all aspects of a feature are imlepement at once - when details are
-And Complete Programming is to a great deal caring about the outcome, meaning the overall user experience.
-That includes things like:
- * does everything work smoothly
- * does it look pleasent
- * are there feature holes
- * how long does it take to find a feature
- * how good and coprehensive
-in our own mind things are easy.
-We want to create this awesome new program that is able of doing such and such
-and it will be exactly want we want. Only we are capable to do that.
-Just in practice things get hairy. Dirty overcomplex code nasty bugs,
-unloved pending peripheral work .. and so on. You probably been there done that
-Thats how it always starts right
- since all the rest will be just about
- practical work. But that fine because we love to program. Especially when its
- creative and we feel productive - without all that life sucking overhead.
- And of course the result should be perfect. Problem is, we don't get there by
- just hacking away. Noone I met has that kind of self discipline. But a framework
- of rules that still allows free dabbling and protects it from damaging a solid
- code base would be still a sufficient amount of fun. And wouldn't it be nice if that
- framework doesn't enforce but actually reduces duplicate work and helps us to
- catch our errors early when fixing is much easier and less painful.
- Sounds like I am still hiding something. Yes by hacking I didn't ment necessarily
- Some maybe don't like to hear that becasue they only consider
- writing documentation as something productive or enjoyable.
- "Working software over comprehensive documentation" was one of the main points
- in the agile manifesto.
- there are aspects about Complete
- Programming that at first sound aweful to many. Bu they actually aren't, just
- changing habits maybe will need a little discipline but the results might be
- Like in art trends or other social dynamics, extreme programming
- acknowledges the shortcomings of the previously popular waterfall methods.
- But while running in the opposite direction it created new ones or left several
- unfixed. Meanwhile sensible people tried to do the right thing anyway and dind't
- followed any recipe slavishly.
- * documentation (user, programmer, comments)
+ As a consequence we count an ugly icon, missing documentation or an badly
+designed internal API equally as a bug as a crashing function. CP is designed
+to deliver that high standard, without packing too much burden on the programer.
+ Firstly all aspects of a feature are imlepement at once - when details are fresh
+in your memory. And since that also includes comments and documentation, you will
+later know what you have done and why, saving a lot of guesswork.
+ Secondly we reduce duplicate work and duplicate data where possible and enforce
+the quality of communication and self reflection. Every vital information will be
+in one repository (holistic!).
+ And thirdly - the development models knows several decoupled, well defined
+stages - so you only care about one goal at a time. This goal reflects the natural
+possibilities and strengths of this stage. Thats why this work doesn't feels like
+a burden - like for instance writing tests out of the cold (and rewriting them
+several time). Even better - some stages allow free minded hacking and bring back
+the fun - you missed for so long. (Play time and serious time - that is holistic
+ * documentation (user, programmer, comments)
Third Step: Imagine some rought logical structures the program is built upon.
Use UML only if you have to, better are empty classes / packages / module with