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
- Title
- Dedication
- Contents at a Glance
- Contents
- About the Author
- About the Technical Reviewer
- Acknowledgments
- Preface
- Chapter 1: Introduction to Software Development
-
Chapter 2: Process Life Cycle Models
- A Model That's not a Model At All: Code and Fix
- Cruising over the Waterfall
- Backing Up the Waterfall
- Loops Are Your Friend
- Evolving the Incremental Model
- Agile Is as Agile Does
- eXtreme Programming (XP)
- XP Overview
- XP Motivation
- The Four Variables
- The Four Values
- The 15 Principles
- The Four Basic Activities
- Implementing XP: The 12 Practices
- The XP Life Cycle
- Scrum, mate
- Conclusion
- References
- Chapter 3: Project Management Essentials
-
Chapter 4: Requirements
- What Types of Requirements Are We Talking About Here?
- Functional Specification?
- But I Don't Like Writing!
- That Natural Language Thing
- Outline of a Functional Specification
- Overview
- Disclaimer
- Author's Name
- Scenarios of Typical Usage
- Detailed Screen-By-Screen Specifications
- Non-requirements
- Open Issues
- Design and Feature Ideas
- Backlog
- One More Thing
- Types of Requirements
- User Requirements
- Domain Requirements
- Non-functional Requirements
- Non-requirements
- Requirements Digging
- Why Requirements Digging Is Hard
- Analyzing the Requirements
- Conclusion
- References
-
Chapter 5: Software Architecture
- General Architectural Patterns
- Pipe-and-filter Architecture
- An Object-Oriented Architectural Pattern
- An MVC Example: Let's Hunt!
- The Problem
- Model
- View
- Controller
- Model
- The Client-Server Architectural Pattern
- The Layered Approach
- The Main Program: Subroutine Architectural Pattern
- Conclusion
- References
- Chapter 6: Design Principles
- Chapter 7: Structured Design
- Chapter 8: Object-Oriented Analysis and Design–An Overview
-
Chapter 9: Object-Oriented Analysis and Design
- PRELUDE: In Which We Set the Scene
- ACT ONE, Scene 1: In Which We Enquire into Analysis
- ACT ONE, Scene 2: In Which We Deign to Design
- ACT TWO, Scene 1: Change in the Right Direction
- ACT TWO, Scene 2: In Which the Design Will also Change, for the Better
- ACT THREE, Scene 1: In Which We Do Design
- ACT FOUR, Scene 1: In Which We Philosophize on Abstraction
- Conclusion
- References
-
Chapter 10: Object-Oriented Design Principles
- Our List of Fundamental Object-Oriented Design Principles
- Encapsulate Things in Your Design That Are Likely to Change
- Code to an Interface Rather Than to an Implementation
- The Open-Closed Principle (OCP)
- The Single Responsibility Principle (SRP)
- Liskov Substitution Principle (LSP)
- The Dependency Inversion Principle (DIP)
- The Interface Segregation Principle (ISP)
- The Principle of Least Knowledge (PLK)
- Class Design Guidelines for Fun and Enjoyment
- Conclusion
- References
- Chapter 11: Design Patterns
-
Chapter 12: Code Construction
- A coding example
- Functions and Methods and Size, Oh My!
- Formatting, Layout, and Style
- General Layout Issues and Techniques
- White Space
- Block and Statement Style Guidelines
- Declaration Style Guidelines
- Commenting Style Guidelines
- Identifier Naming Conventions
- Defensive Programming
- Assertions Can Be Your Friend
- Exceptions and Error Handling
- The Last Word on Coding
- References
- Chapter 13: Debugging
- Chapter 14: Unit Testing
- Chapter 15: Walkthroughs, Code Reviews, and Inspections
- Chapter 16: Wrapping It all Up
- Index
Product information
- Title: Software Development and Professional Practice
- Author(s):
- Release date: July 2011
- Publisher(s): Apress
- ISBN: 9781430238010
You might also like
book
How Software Works
How Software Works explains everyday software to the non-programmer.
book
The (Delicate) Art of Bureaucracy
Mark Schwartz, author of leadership classics A Seat at the Table and The Art of Business …
book
Making Software
Many claims are made about how certain tools, technologies, and practices improve software development. But which …
book
Seriously Good Software
Serious developers know that code can always be improved. With each iteration, you make optimizations—small and …