Index of All Tips

  1. Chapter 1: Introduction
  2. Chapter 2: Preparing for the Course
      1. 2.1 Find out what to expect
      2. 2.2 Climb the learning curve
      3. 2.3 Brace for the workload
      4. 2.4 Find your teammates
  3. Chapter 3: Managing Requirements
    1. 3A. Proposing a project
      1. 3.1 Choose a worthy cause
      2. 3.2 Know your market
      3. 3.3 Target real users
      4. 3.4 Dream 'grand', promise 'doable'
      5. 3.5 Name it well
      6. 3.6 Sell the idea
    2. 3B. Dealing with product features
      1. 3.7 Put vision before features
      2. 3.8 Focus features
      3. 3.9 Categorise, prioritise
      4. 3.10 Focus users
      5. 3.11 Get early feedback
      6. 3.12 Gently exceed expectations
    3. 3C. Managing product releases
      1. 3.13 Publicise your product
      2. 3.14 Release gradually
      3. 3.15 Nurture early adopters
      4. 3.16 Act professional
      5. 3.17 Plan maintenance
  4. Chapter 4: Managing Project Risks
      1. 4.1 Attack risks early and continuously
      2. 4.2 Document risks
    1. 'HOW TO' SIDEBAR 4A: How to tackle common project risks
      1. 4.3 Building the wrong product
      2. 4.4 Problematic team members
      3. 4.5 Lack of skills
      4. 4.6 Sub-standard sub-groups
      5. 4.7 Missing the quality boat
      6. 4.8 Going down the wrong path
      7. 4.9 Overshooting the deadline
      8. 4.10 Unexpected delays
      9. 4.11 Bad estimates
  5. Chapter 5: Working as a Team
    1. 5A. Teaming up
      1. 5.1 The team matters. Take it seriously.
      2. 5.2 Exercise 'due diligence'
      3. 5.3 Balance skills
      4. 5.4 Look for teammates, not buddies
      5. 5.5 Assign roles
    2. 5B. Leading a team
      1. 5.6 Have a leader
      2. 5.7 Rotate leadership
      3. 5.8 Delegate authority
      4. 5.9 Strive for consensus
    3. 'HOW TO' SIDEBAR 5C : How to fit into your team
      1. 5.10 My team overruled me!
      2. 5.11 My team cut me out!
      3. 5.12 I am a 'spare wheel'!
      4. 5.13 I laboured in vain
      5. 5.14 Lost in translation
      6. 5.15 I lag behind
    4. 'HOW TO' SIDEBAR 5D: How to handle problematic team members
      1. 5.16 Abdicator
      2. 5.17 Talker
      3. 5.18 Lone ranger
      4. 5.19 Dominator
      5. 5.20 Suffering genius
      6. 5.21 Busy bee
      7. 5.22 Personal issue guy
      8. 5.23 Unwilling leader
      9. 5.24 Greenhorn
      10. 5.25 Weak link
      11. 5.26 Cheater
      12. 5.27 Slipshod
      13. 5.28 Hero
      14. 5.29 Freeloader
      15. 5.30 Observer
      16. 5.31 Laid back Jim
    5. 'HOW TO' SIDEBAR 5E: How to deal with team dynamics issues
      1. 5.32 Tug of war
      2. 5.33 Lifeline leader
      3. 5.34 Random team
      4. 5.35 Negative-synergy team
      5. 5.36 Clique
      6. 5.37 Herd of cats
    6. 5F. Increasing team synergy
      1. 5.38 Build team spirit early
      2. 5.39 Build a team identity
      3. 5.40 Build positive group norms
      4. 5.41 Keep in touch
      5. 5.42 Work together, work alone
  6. Chapter 6: Working  with Your Supervisor
      1. 6.1 Have realistic expectations
      2. 6.2 Ask for opinions, not decisions
      3. 6.3 Prefer writing to calling
      4. 6.4 Do not drop by unannounced
      5. 6.5 Respect supervisor's time
      6. 6.6 Allow time to respond
      7. 6.7 Let the supervisor set the tone
      8. 6.8 Keep in the loop
      9. 6.9 Do not blame the supervisor
  7. Chapter 7: Project Meetings
    1. 7A. Running a project meeting
      1. 7.1 Have an agenda
      2. 7.2 Appoint a moderator
      3. 7.3 Start on time
      4. 7.4 Make it short, but not too short
      5. 7.5 Take notes
      6. 7.6 Summarise
      7. 7.7 Fix finish time, finish on time
      8. 7.8 First things first
      9. 7.9 Set aside regular meeting slots
      10. 7.10 Use brainstorming
      11. 7.11 Set ground rules
      12. 7.12 Avoid win-lose situations
      13. 7.13 Use meetings for meetings
    2. 'HOW TO' SIDEBAR 7B: How to handle 'meeting poopers'
      1. 7.14 The distractor
      2. 7.15 Native speaker
      3. 7.16 Chatterbox
      4. 7.17 Topic jumper
      5. 7.18 Meeting addict
      6. 7.19 No show
      7. 7.20 Multi-tasker
  8. Chapter 8: Planning and Tracking the Project
      1. 8.1 Have a plan
      2. 8.2 Know objectives
      3. 8.3 Get everyone on board
      4. 8.4 Choose iterative
      5. 8.5 Order features
      6. 8.6 Know when to detail
      7. 8.7 Align to external milestones
      8. 8.8 Choose a simple format
      9. 8.9 Time-box iterations
      10. 8.10 Start with short iterations
      11. 8.11 Use same size iterations
      12. 8.12 Estimate size, derive duration
      13. 8.13 Define verifiable tasks
      14. 8.14 Resist 'guesstimating' effort
      15. 8.15 Estimate collaboratively
      16. 8.16 Have 'floating' tasks
      17. 8.17 Think in hours, not days
      18. 8.18 Do not fake precision
      19. 8.19 It takes longer than you might think
      20. 8.20 Include things taken for granted
      21. 8.21 Plan sincerely
      22. 8.22 Track visibly
      23. 8.23 Refine regularly
      24. 8.24 Add buffers
      25. 8.25 Drop features when behind
      26. 8.26 Do not slack when ahead
  9. Chapter 9: Using Project Tools
    1. 'HOW TO' SIDEBAR 9A: How to use tools for different project tasks
      1. 9.1 Coding
      2. 9.2 Profiling
      3. 9.3 Metrics
      4. 9.4 Configuration Management
      5. 9.5 Documentation
      6. 9.6 Testing
      7. 9.7 Collaboration
      8. 9.8 Project management
      9. 9.9 Building
      10. 9.10 Issue tracking
      11. 9.11 Logging
    2. 9B. Using tools
      1. 9.12 Do not expect silver bullets
      2. 9.13 Learn tools early
      3. 9.14 Appoint tool 'gurus'
      4. 9.15 Look for better tools
      5. 9.16 Prefer established software
      6. 9.17 Choose a common set of tools
      7. 9.18 Automate
      8. 9.19 Be a toolsmith
      9. 9.20 Document usage
  10. Chapter 10: Designing the Product
    1. 10A. General design tips
      1. 10.1 Abstraction is your friend
      2. 10.2 Separate concerns
      3. 10.3 Don't talk to strangers
      4. 10.4 Encapsulate
      5. 10.5 Preserve conceptual integrity
      6. 10.6 Standardise solutions
      7. 10.7 Use patterns
      8. 10.8 Do not overuse patterns
      9. 10.9 Value simplicity
      10. 10.10 Increase Fan-in, decrease Fan-out
      11. 10.11 Give brute force a chance
      12. 10.12 Less is more
      13. 10.13 Do not forget non-functional qualities
      14. 10.14 Beware of premature optimisation
      15. 10.15 Avoid analysis paralysis
      16. 10.16 Polish documents later
      17. 10.17 Remember the reason
    2. 10B. UI design tips
      1. 10.18 Design it for the user
      2. 10.19 Usability is king
      3. 10.20 Do a prototype
      4. 10.21 Be different, if you must
    3. 10C. API design tips
      1. 10.22 Talk to API clients
      2. 10.23 Choose descriptive names
      3. 10.24 Name consistently
      4. 10.25 Hide internal details
      5. 10.26 Complete primitive operations
      6. 10.27 Avoid bloat
      7. 10.28 Avoid 'Swiss Army Knife' operations
      8. 10.29 Make common things easy, rare things possible
      9. 10.30 Promise less
      10. 10.31 Specify abnormal behaviours
      11. 10.32 Choose atomic over multi-step
      12. 10.33 Match the abstraction
      13. 10.34 Keep to the same level of abstraction
      14. 10.35 Evolve as necessary
      15. 10.36 Document the API
      16. 10.37 Generate documentation from code
  11. Chapter 11: Implementation
      1. 11.1 Refactor often
      2. 11.2 Name well
      3. 11.3 Be obvious
      4. 11.4 No misuse of syntax
      5. 11.5 Avoid error-prone practices
      6. 11.6 Use conventions
      7. 11.7 Minimise global variables
      8. 11.8 Avoid magic numbers
      9. 11.9 Throw out garbage
      10. 11.10 Minimise duplication
      11. 11.11 Make comments unnecessary
      12. 11.12 Be simple
      13. 11.13 Code for humans
      14. 11.14 Tell a good story
      15. 11.15 Do not assume. Clarify. Assert.
      16. 11.16 Choose an approach and stick with it
      17. 11.17 Do not release temporary code
      18. 11.18 Heed the compiler
      19. 11.19 Strategise error handling
      20. 11.20 Have sufficient verbosity
      21. 11.21 Fly with a black box
      22. 11.22 Greet the user, but briefly
      23. 11.23 Shutdown properly
      24. 11.24 Stick to the domain terms
      25. 11.25 Throw away the prototype
      26. 11.26 Fix before you add
      27. 11.27 Never check-in broken code
      28. 11.28 Do not program by coincidence
      29. 11.29 Read good code
      30. 11.30 Do code reviews
      31. 11.31 Stop when 'good enough'
      32. 11.32 Create installers if you must
      33. 11.33 Sign your work
      34. 11.34 Respect copyrights
      35. 11.35 Have fun
    1. 'HOW TO' SIDEBAR 11A: How to achieve non-functional qualities
      1. 11.36 Reliability
      2. 11.37 Robustness
      3. 11.38 Maintainability
      4. 11.39 Efficiency
      5. 11.40 Security
      6. 11.41 Reusability
      7. 11.42 Testability
      8. 11.43 Scalability
      9. 11.44 Flexibility/Extensibility
      10. 11.45 Usability
  12. Chapter 12: Testing
    1. 12A. Test planning
      1. 12.1 Know how much to test
      2. 12.2 Have a plan
      3. 12.3 Put someone in charge
      4. 12.4 Insist on iterative
      5. 12.5 Consider Test-Driven
      6. 12.6 Have testing policies
      7. 12.7 Insist on developer testing
      8. 12.8 Consider cross testing
      9. 12.9 Choose competent testers
      10. 12.10 Automate testing
      11. 12.11 Smoke test
    2. 12B. Increasing testability
      1. 12.12 Opt for simplicity
      2. 12.13 Use assertions, use exceptions
      3. 12.14 Provide a testing API
      4. 12.15 Use built-in self-tests
      5. 12.16 Decouple the UI
      6. 12.17 Maintain audit log
    3. 12C. Developer testing
      1. 12.18 Do it
      2. 12.19 Follow the implementation strategy
    4. 12D. System testing
      1. 12.20 When system testing, be a system tester
      2. 12.21 Minimise risk
      3. 12.22 Gauge test coverage
      4. 12.23 Keep the forest in view
      5. 12.24 Start by writing conceptual test cases
      6. 12.25 Look in the right places
      7. 12.26 Reproduce errors
      8. 12.27 Isolate errors
      9. 12.28 Make bug reports work
      10. 12.29 Test non-functional qualities
      11. 12.30 Test on clean machines
    5. 12E. Some general testing tips
      1. 12.31 Be systematic
      2. 12.32 Accept your fallibility
      3. 12.33 'Trivial' is not immune
      4. 12.34 Do not test gently
      5. 12.35 Write self-documenting tests
      6. 12.36 One invalid value per test case
      7. 12.37 Make every test case count
      8. 12.38 Have variety in test inputs
      9. 12.39 Know how to use 'unverified' test cases
      10. 12.40 Submit your tests
    6. 12F. Debugging
      1. 12.41 Plan for debugging
      2. 12.42 Be systematic
      3. 12.43 Use the debugger
      4. 12.44 Write the test before the fix
      5. 12.45 Minimise mess, clean up after
      6. 12.46 Do not patch the symptom
      7. 12.47 Summon backup
      8. 12.48 Fix it
      9. 12.49 Leave some alone, if you must
  13. Chapter 13: Documenting
    1. 13A. General tips on documenting
      1. 13.1 Give a good first impression
      2. 13.2 Write to the target audience
      3. 13.3 Read it
      4. 13.4 Describe top-down
      5. 13.5 'Accurate and complete' is not enough
      6. 13.6 Edit collaboratively
      7. 13.7 Do not duplicate text chunks
      8. 13.8 Make it as short as possible
      9. 13.9 Mention the expected, emphasise the unique
      10. 13.10 Support your claims
      11. 13.11 Make it cohesive and consistent
      12. 13.12 Use slides to guide explanations
      13. 13.13 Do not leave it to the end
    2. 13B. Writing user documentation
      1. 13.14 Polish it
      2. 13.15 Honour the contract
      3. 13.16 Write to the user
    3. 13C. Writing developer documentation
      1. 13.17 Explain things, not list diagrams
    4. 13D. Writing the project report
      1. 13.18 If you did not write it down, it did not happen
      2. 13.19 Show how you learned from experience
  14. Chapter 14: Project Presentation
      1. 14.1 Practice, practice, practice
      2. 14.2 Arrive before time
      3. 14.3 End on time
      4. 14.4 Be ready for questions
      5. 14.5 Focus on the important stuff
      6. 14.6 Avoid overselling
      7. 14.7 Content before slides
      8. 14.8 Never talk faster to catch up
      9. 14.9 Be refreshingly different
      10. 14.10 Banish Murphy from the demo
      11. 14.11 Dress suitably
      12. 14.12 Avoid irritants
      13. 14.13 The audience is not you
      14. 14.14 Stop at stations
      15. 14.15 Minimise text
      16. 14.16 Show confidence
      17. 14.17 Be careful with 'imaginary' features
      18. 14.18 Know the value of Q&A
      19. 14.19 Show team spirit
 

Giving feedback

Any suggestions to improve this book? Any tips you would like to add? Any aspect of your project not covered by the book? Anything in the book that you don't agree with? Noticed any errors/omissions? Please use the link below to provide feedback, or send an email to damith[at]comp.nus.edu.sg

Sharing this book helps too!

 

---| This page is from the free online book Practical Tips for Software-Intensive Student Projects V3.0, Jul 2010, Author: Damith C. Rajapakse |---

free statistics free hit counter javascript