1. Herbert Breunung
  2. Kephra


Kephra / doc / CompleteProgramming.pod

=head1 Complete Programming

    This document describes the method the Kephra editor is developed with.
    Its highest aim is to have at all times a usable program with the
    highest quality at all levels while still allowing programming be fun.

=head2 Overview


    The name is a reminder that we reach for the impossible,
    because software is never complete. So please focus AND relax.

    I strongly dislike strict rules imposed on me and make fun of people that
    produce theories with three letter acronyms that try to be the answer to everything.
    But now I am standing here, trying to "sell" you yet another programming methodology.
    That IS irony, isn't it? At least I use only two letters beause this is more important.

=head3 Intentions

    Well, several reasons brought me here.

    1) I always wanted a sane balance between the old bureaucratic waterfall method,
       and the modern extreme or agile programming, which is a bit too shortsighted,
       and accumulates additional work as the project grows.
       It should be possible to combine sound planning, practicability and quick results.

    2) Writing tests is no silver bullet and is used for several competing purposes.

    3) The awesome powers of prototypes are still not fully used.

    4) All methodologies I know of overlook several aspects of the product.
       That includes even "documentation driven development",
       which gave important impulses for the creation of CP.

    5) New tools like hg or git allow new workflows which solve pending problems.

=head3 Main Goal

    Highest aim of CP is the conscience the code is produced with. As result you get
=item a superb overall user experience
=item quality code
=item transparent project planning and status
=item room for experiments and changes without trouble

=head3 Principles

=item Every action has a productive and lasting (yet changable) result.
=item All code, data and metadata of the project go into one repository.
=item Before implenenting a functionality that isn't just a lib call write a prototype.
=item Before implementing a use case, write a prototype.
=item These two types of prototypes stay in their respective dir/branch.
=item After the prototype you write the docs, then the code and then the test. 
=item When implementing a feature, do also the docs, test, GUI and the configs.

=head2 Details

=head3 Planning

aprox. feature set
what kind of team to solve it with

what technologies, languages, libs, os, other tools
fallback alternatives or areas you might expand into

=head3 Prototypes

=head3 Documentation

=head3 Code

=head3 Tests

=head3 Completeness

   * documentation (user, programmer, comments)
   * prototypes
   * supply libs 
   * tests
   * logic
   * visuals
   * configs

=head3 Releases

parts to do

=over 4