Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

O'Reilly logo
Software Development and Professional Practice

Book Description

Software Development and Professional Practice reveals how to design and code great software. What factors do you take into account? What makes a good design? What methods and processes are out there for designing software? Is designing small programs different than designing large ones? How can you tell a good design from a bad one? You'll learn the principles of good software design, and how to turn those principles back into great code.

Software Development and Professional Practice is also about code construction—how to write great programs and make them work. What, you say? You've already written eight gazillion programs! Of course I know how to write code! Well, in this book you'll re-examine what you already do, and you'll investigate ways to improve. Using the Java language, you'll look deeply into coding standards, debugging, unit testing, modularity, and other characteristics of good programs. You'll also talk about reading code. How do you read code? What makes a program readable? Can good, readable code replace documentation? How much documentation do you really need?

This book introduces you to software engineering—the application of engineering principles to the development of software. What are these engineering principles? First, all engineering efforts follow a defined process. So, you'll be spending a bit of time talking about how you run a software development project and the different phases of a project. Secondly, all engineering work has a basis in the application of science and mathematics to real-world problems. And so does software development! You'll therefore take the time to examine how to design and implement programs that solve specific problems.

Finally, this book is also about human-computer interaction and user interface design issues. A poor user interface can ruin any desire to actually use a program; in this book, you'll figure out why and how to avoid those errors.

Software Development and Professional Practice covers many of the topics described for the ACM Computing Curricula 2001 course C292c Software Development and Professional Practice. It is designed to be both a textbook and a manual for the working professional.

What you'll learn

  • How to design and code great software

  • What methods and processes are available to help you design great software

  • How to apply software engineering principles to your daily coding practice

  • How to tell a good design from a bad one?

  • Understand the characteristics of good programs

  • How to construct professional standard code that you can be proud to show

  • Understand all about coding standards, and apply them to real Java coding

  • Explore debugging, unit testing and modularity

  • All about object-oriented programming (OOP) design principles and great coding

  • How to apply the principles you've learned to specific and real-world coding problems

  • A companion to the ACM Computing Curricular 2001 source C202c

Who this book is for

Software Development and Professional Practice is designed to be both a textbook and a manual for the working professional programmer, and any student of programming who wants to learn the art of the trade. This book assumes you know some Java, enough to read its examples at least, and that you've already done some programming. Now you want to write great code!

This book covers many of the topics described for the ACM Computing Curricula 2001 course C292c Software Development and Professional Practice, and will be a great companion to anyone studying this course.

Table of Contents

  1. Title
  2. Dedication
  3. Contents at a Glance
  4. Contents
  5. About the Author
  6. About the Technical Reviewer
  7. Acknowledgments
  8. Preface
  9. Chapter 1: Introduction to Software Development
    1. What We're Doing
    2. So, How to Develop Software?
    3. Conclusion
    4. References
  10. Chapter 2: Process Life Cycle Models
    1. A Model That's not a Model At All: Code and Fix
    2. Cruising over the Waterfall
    3. Backing Up the Waterfall
    4. Loops Are Your Friend
    5. Evolving the Incremental Model
    6. Agile Is as Agile Does
    7. eXtreme Programming (XP)
    8. XP Overview
    9. XP Motivation
    10. The Four Variables
    11. The Four Values
    12. The 15 Principles
    13. The Four Basic Activities
    14. Implementing XP: The 12 Practices
    15. The XP Life Cycle
    16. Scrum, mate
    17. Conclusion
    18. References
  11. Chapter 3: Project Management Essentials
    1. Project Planning
    2. Project Organization
    3. Risk Analysis
    4. Resource Requirements
    5. Work Breakdown and Task Estimates
    6. Project Schedule
    7. Project Oversight
    8. Status Reviews and Presentations
    9. Defects
    10. The Post-Mortem
    11. Conclusion
    12. References
  12. Chapter 4: Requirements
    1. What Types of Requirements Are We Talking About Here?
    2. Functional Specification?
    3. But I Don't Like Writing!
    4. That Natural Language Thing
    5. Outline of a Functional Specification
    6. Overview
    7. Disclaimer
    8. Author's Name
    9. Scenarios of Typical Usage
    10. Detailed Screen-By-Screen Specifications
    11. Non-requirements
    12. Open Issues
    13. Design and Feature Ideas
    14. Backlog
    15. One More Thing
    16. Types of Requirements
    17. User Requirements
    18. Domain Requirements
    19. Non-functional Requirements
    20. Non-requirements
    21. Requirements Digging
    22. Why Requirements Digging Is Hard
    23. Analyzing the Requirements
    24. Conclusion
    25. References
  13. Chapter 5: Software Architecture
    1. General Architectural Patterns
    2. Pipe-and-filter Architecture
    3. An Object-Oriented Architectural Pattern
    4. An MVC Example: Let's Hunt!
    5. The Problem
    6. Model
    7. View
    8. Controller
    9. Model
    10. The Client-Server Architectural Pattern
    11. The Layered Approach
    12. The Main Program: Subroutine Architectural Pattern
    13. Conclusion
    14. References
  14. Chapter 6: Design Principles
    1. The Design Process
    2. Desirable Design Characteristics (Things Your Design Should Favor)
    3. Design Heuristics
    4. Designers and Creativity
    5. Conclusion
    6. References
  15. Chapter 7: Structured Design
    1. Structured Programming
    2. Stepwise Refinement
    3. Modular Decomposition
    4. Top-Down Decomposition
    5. Conclusion
    6. References
    7. Appendix: The Complete Non-Recursive Eight-Queens Program
  16. Chapter 8: Object-Oriented Analysis and Design–An Overview
    1. An Object-Oriented Analysis and Design Process
    2. Doing the Process
    3. Conclusion
    4. References
  17. Chapter 9: Object-Oriented Analysis and Design
    1. PRELUDE: In Which We Set the Scene
    2. ACT ONE, Scene 1: In Which We Enquire into Analysis
    3. ACT ONE, Scene 2: In Which We Deign to Design
    4. ACT TWO, Scene 1: Change in the Right Direction
    5. ACT TWO, Scene 2: In Which the Design Will also Change, for the Better
    6. ACT THREE, Scene 1: In Which We Do Design
    7. ACT FOUR, Scene 1: In Which We Philosophize on Abstraction
    8. Conclusion
    9. References
  18. Chapter 10: Object-Oriented Design Principles
    1. Our List of Fundamental Object-Oriented Design Principles
    2. Encapsulate Things in Your Design That Are Likely to Change
    3. Code to an Interface Rather Than to an Implementation
    4. The Open-Closed Principle (OCP)
    5. The Single Responsibility Principle (SRP)
    6. Liskov Substitution Principle (LSP)
    7. The Dependency Inversion Principle (DIP)
    8. The Interface Segregation Principle (ISP)
    9. The Principle of Least Knowledge (PLK)
    10. Class Design Guidelines for Fun and Enjoyment
    11. Conclusion
    12. References
  19. Chapter 11: Design Patterns
    1. Design Patterns and the Gang of Four
    2. Patterns We Can Use
    3. Conclusion
    4. References
  20. Chapter 12: Code Construction
    1. A coding example
    2. Functions and Methods and Size, Oh My!
    3. Formatting, Layout, and Style
    4. General Layout Issues and Techniques
    5. White Space
    6. Block and Statement Style Guidelines
    7. Declaration Style Guidelines
    8. Commenting Style Guidelines
    9. Identifier Naming Conventions
    10. Defensive Programming
    11. Assertions Can Be Your Friend
    12. Exceptions and Error Handling
    13. The Last Word on Coding
    14. References
  21. Chapter 13: Debugging
    1. What’s an Error, Anyway?
    2. What Not To Do
    3. An Approach to Debugging
    4. Source Code Control
    5. One Last Thought on Coding and Debugging – Pair Programming
    6. Conclusion
    7. References
  22. Chapter 14: Unit Testing
    1. The Problem with Testing
    2. That Testing Mindset
    3. When to Test?
    4. What to Test?
    5. Characteristics of Tests
    6. How to Write a Test
    7. JUnit: A Testing Framework
    8. Testing Is Good
    9. Conclusion
    10. References
  23. Chapter 15: Walkthroughs, Code Reviews, and Inspections
    1. Walkthroughs, Reviews, and Inspections – Oh My!
    2. Walkthroughs
    3. Code Reviews
    4. Code Inspections
    5. Summary of Review Methodologies
    6. Defect Tracking Systems
    7. Conclusion
    8. References
  24. Chapter 16: Wrapping It all Up
    1. What Have You Learned?
    2. What to Do Next?
    3. References
  25. Index