Advertisement
Guest User

Untitled

a guest
Mar 23rd, 2019
73
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 3.62 KB | None | 0 0
  1. ## 1 + 1 + N rule set of software development. ##
  2.  
  3. This is a rule set which can be applied to relative compleex programming tasks. The rule set's purpose is to lead to a better understanding, knowledge and implementation.
  4.  
  5. The rule set cannot be applied as single developer, at least four people must be involved.
  6.  
  7. **Why is this important ?**
  8.  
  9. No single developer should ever be tasked by herself to implement business/technical critical features.
  10.  
  11. The sitting-in-a-corner developer is a bad pratice due to multiple factors. Some arguments below:
  12. - the thought process of a single individual is not as powerful as e.g two individuals.
  13. - an individual cannot with itself discuss and evaluate in-depth thoughts, opinions and possible solutions of a task.
  14. - no knowledge sharing up-front and enablemnet of discussions and interaction will is left out and will most likely tribute to less attractive implementation.
  15. - time spent during this cermony is decreaed but will be increased in the long run.
  16.  
  17. **The cermony of the 1 + 1 + N rule set.**
  18.  
  19. Two (the 1 + 1) individuals must sit together, with no time box.
  20.  
  21. These two individuals must discuss and evaluate the complexity and nature around the task at hand. This is relative and therefore the rule set can be applied to every level of complexity and competence.
  22.  
  23. (If a task takes longer time than a week to implement it should be broken down into smaller tasks. Both individuals contribute to the breakdown.)
  24.  
  25. Whenever the task is understood the actual implementation can be applied. Still with the same two individuals present and contributing to the code (MOB/XP programming should be applied here).
  26.  
  27. This continues until an actual implementaion is present. This can take hours or days.
  28.  
  29. The two individuals will now break up.
  30.  
  31. Now the implementation will be presented by each implementors, in an in-depth review, with another individual which has not been present previously (a team member perhaps, or maybe a community member).
  32.  
  33. It's important that each of the implementors presents and reviews the implementaion alone with a secound individual presen. This is due to the possible peer pressure factor of both implementors being present.
  34.  
  35. Each implementor will give a brief introduction to the source code and explain what it solves. And the implementor will let the individual without knowledge of the sourcecode find her way through the
  36. code. It's up the individual and the implementor to ask questions along the review, which can take hours. This is about talking, sharing, explaining and asking questions. Use paper for drawing and share that paper amongst you. Save the paper when you are done, for later use.
  37.  
  38. Everytime a question is asked based the implementaion detail it must be written down for later use.
  39.  
  40. When the individual, which is not the implementor, is certain and has proven the understanding of the implementaion and sourcecode those two individuals break up.
  41.  
  42. Now all four individuals gather. The two original implementors keep quiet while the two non-implementors review the sourcecode together.
  43.  
  44. This is to make sure all understand the source code and what it does. The two implementors write down possible questions or discussions points that the two non-implementors might come up with, but without upfront involvement.
  45.  
  46. Whenever the two non-implementors are done reviewing to a satisfactory point the two implementors take up any discussion and questions that arose during the gathering.
  47.  
  48. These ceremonies will lead to an up front, perhaps time consuming chain of events, but will in the long run diminish the need for spending longer on understanding and self-guidance around certain pieces of sourcecode.
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement