Software development : an open source approach / Allen Tucker, Ralph Morelli, Chamindra de Silva.

By:

Tucker, Allen B

Contributor(s):

Material type: Text

TextSeries: Chapman & Hall/CRC innovations in software engineering and software developmentPublication details: Boca Raton, FL : CRC Press, c2011.Description: xxvii, 370 p. : ill. ; 25 cmISBN:

9781439812907 (hardcover : alk. paper)
143981290X (hardcover : alk. paper)

Subject(s):

DDC classification:

005.3 TUC

Holdings
Item type	Current library	Call number	Copy number	Status	Barcode
Standard Loan	Thurles Library Main Collection	005.3 TUC (Browse shelf(Opens below))		Available	R13348KRCT
Standard Loan	Thurles Library Main Collection	005.3 TUC (Browse shelf(Opens below))	1	Available	R09970KRCC
Standard Loan	Thurles Library Main Collection	005.3 TUC (Browse shelf(Opens below))	1	Available	R09973KRCC
Standard Loan	Thurles Library Main Collection	005.3 TUC (Browse shelf(Opens below))	1	Available	R09976KRCC

Enhanced descriptions from Syndetics:

To understand the principles and practice of software development, there is no better motivator than participating in a software project with real-world value and a life beyond the academic arena. Software Development: An Open Source Approach immerses students directly into an agile free and open source software (FOSS) development process. It focuses on the methodologies and goals that drive the development of FOSS, combining principles with real-world skill building, such as debugging, refactoring, and writing.

The text explains the software development process through an integration of FOSS principles, agile techniques, modern collaboration tools, community involvement, and teamwork. The authors highlight the value of collaboration as a fundamental paradigm for software development. They show how an effective development team can often create better quality software than an individual working in isolation.

Written by experienced software developers and educators, this book enables students to gain a rich appreciation of the principles and practice of FOSS development. It also helps them become better writers, programmers, and software community members.

Web Resource

The book's companion website provides a wealth of resources:

Downloadable FOSS development projects, including design documents, use cases, and code bases A discussion forum for instructors and students to share their experiences and exchange ideas about particular issues raised by these projects Supporting materials for common FOSS development tasks, such as setting up a version control system, an IDE, a project code base, and a unit test suite Additional exercises that reflect a wide variety of software projects and other activities

Includes bibliographical references and index.

Table of contents provided by Syndetics

List of Figures (p. xi)
List of Tables (p. xv)
Preface (p. xvii)
Acknowledgments (p. xxv)
Authors (p. xxvii)
1 Overview and Motivation (p. 1)
1.1 Software (p. 1)
1.1.1 Types of Software (p. 2)
1.1.2 The Changing Landscape (p. 5)
1.1.3 Who Are the Developers? (p. 7)
1.1.4 Strategic Choices (p. 8)
1.2 Free and Open Source Software (FOSS) (p. 11)
1.2.1 Origins and Growth (p. 12)
1.2.2 Licensing (p. 16)
1.2.3 Worldwide Impact (p. 18)
1.2.4 Humanitarian FOSS (p. 19)
1.3 Two Case Studies (p. 20)
1.3.1 RMH Homebase (p. 20)
1.3.2 Sahana (p. 20)
1.4 Summary (p. 22)
Exercises (p. 23)
2 Working with a Project Team (p. 27)
2.1 Key FOSS Activities (p. 27)
2.1.1 Agile Development (p. 27)
2.1.2 Using Patterns (p. 29)
2.1.3 Reading and Writing Code (p. 31)
2.1.4 Documentation (p. 34)
2.1.5 On-Line Help (p. 37)
2.2 Client-Oriented vs Community-Oriented Projects (p. 37)
2.2.1 Project Evolution (p. 40)
2.2.2 Similarities and Differences (p. 42)
2.3 Working on a Client-Oriented Project (p. 44)
2.3.1 Members, Roles, and Tasks (p. 44)
2.3.2 Team Dynamics (p. 47)
2.3.3 Scheduling, Milestones, and To-Do Lists (p. 48)
2.4 Joining a Community-Oriented Project (p. 50)
2.4.1 Project Selection (p. 52)
2.4.2 First Contact with the Project (p. 53)
2.4.3 Norms for Good Citizenship (p. 56)
2.4.4 Becoming a User First (p. 58)
2.5 Summary (p. 60)
Exercises (p. 60)
3 Using Project Tools (p. 63)
3.1 Collaboration Tools (p. 63)
3.1.1 Asynchronous Communication (p. 64)
3.1.2 Synchronous Communication (p. 65)
3.1.3 Shared Documents (p. 66)
3.2 Code Management Tools (p. 67)
3.2.1 The IDE (p. 68)
3.2.2 The Software Stack (p. 70)
3.2.3 The Version Control System (p. 72)
3.2.4 The Bug Tracker (p. 77)
3.3 Run-Time System Constraints (p. 82)
3.3.1 Performance (p. 82)
3.3.2 Web Hosting (p. 83)
3.3.3 Licensing (p. 83)
3.3.4 Platform (p. 84)
3.4 Summary (p. 84)
Exercises (p. 85)
4 Software Architecture (p. 87)
4.1 Architectural Patterns (p. 87)
4.2 Layers, Cohesion, and Coupling (p. 89)
4.2.1 Using Metrics to Evaluate Cohesion and Coupling (p. 93)
4.3 Security (p. 95)
4.3.1 Architectural Vulnerabilities (p. 96)
4.3.2 User-Level Security (p. 97)
4.4 Concurrency, Race Conditions, and Deadlocks (p. 100)
4.5 Summary (p. 105)
Exercises (p. 105)
5 Working with Code (p. 107)
5.1 Bad Smells and Metrics (p. 108)
5.1.1 Identifying Bad Smells (p. 108)
5.1.2 Software Metrics (p. 110)
5.2 Refactoring (p. 111)
5.2.1 Example 1: Removing Useless Functions (p. 114)
5.2.2 Example 2: Removing a Layering Violation (p. 114)
5.3 Testing (p. 117)
5.3.1 Unit Testing Tools (p. 119)
5.3.2 Test Case Design (p. 120)
5.3.3 A Strategy for Sequencing Unit Tests (p. 128)
5.4 Debugging (p. 129)
5.4.1 Tool Use vs Developer Skill (p. 130)
5.4.2 Example 1: A User Interface Bug (p. 131)
5.4.3 Example 2: A Multi-Level Bug (p. 133)
5.5 Extending the Software for a New Project (p. 134)
5.5.1 A New Use Case (p. 135)
5.5.2 Impact on the Code Base (p. 136)
5.5.3 Team Discussions (p. 139)
5.6 Summary (p. 140)
Exercises (p. 140)
6 Developing the Domain Classes (p. 143)
6.1 Understanding the Current System (p. 143)
6.1.1 Reading a Design Document (p. 144)
6.1.2 Reading Code (p. 147)
6.1.3 Examining the Domain Classes (p. 150)
6.2 Adding New Features (p. 151)
6.2.1 Top-Down Analysis/Bottom-Up Development (p. 154)
6.2.2 Modifying the Domain Classes (p. 155)
6.2.3 Documentation and Bulletproofing (p. 158)
6.3 Class Design Principles and Practice (p. 162)
6.3.1 Using What's Already There (p. 163)
6.3.2 Adding a New Domain Class (p. 164)
6.4 Managing the Ripple Effect (p. 166)
6.4.1 Unit Testing the New Code (p. 166)
6.4.2 Refactoring the New Code Base (p. 169)
6.5 Summary (p. 171)
Exercises (p. 171)
7 Developing the Database Modules (p. 173)
7.1 Design Principles and Practice (p. 174)
7.1.1 Database Creation (p. 175)
7.1.2 Connecting the Program to the Database (p. 176)
7.1.3 Tables (p. 178)
7.1.4 Normalization and Keys (p. 180)
7.1.5 Backup and Recovery (p. 181)
7.2 Working with a Database (p. 182)
7.2.1 Table Creation (p. 184)
7.2.2 Table Searching (p. 185)
7.2.3 Table Insertion, Deletion, and Updating (p. 187)
7.3 Database Security and Integrity (p. 188)
7.3.1 Database-Level Permissions (p. 189)
7.3.2 User-Level Permissions (p. 189)
7.3.3 Controlling Concurrency (p. 192)
7.4 Adding New Software Features: Database Impact (p. 193)
7.4.1 Items 1 and 9d: Volunteer Status and Application (p. 195)
7.4.2 Item 3: Calendar View (p. 198)
7.5 Summary (p. 201)
Exercises (p. 202)
8 Developing the User Interface (p. 205)
8.1 Design Principles and Practice (p. 205)
8.1.1 The Model-View-Controller Pattern (p. 207)
8.1.2 Sessions, Query Strings, and Global Variables (p. 210)
8.1.3 Ensuring Security at the User Interface (p. 213)
8.2 Working with Code (p. 218)
8.2.1 Reading Deeply (p. 219)
8.2.2 Debugging as a Community Activity (p. 224)
8.3 Adding New Features: User Interface Impact (p. 230)
8.3.1 Item 1: Volunteer Status (p. 230)
8.3.2 Item 2: Make Active/Inactive (p. 235)
8.3.3 Item 3: Calendar View (p. 237)
8.4 Summary (p. 239)
Exercises (p. 240)
9 User Support (p. 243)
9.1 Technical Writing (p. 243)
9.1.1 Knowing Your Audience (p. 244)
9.1.2 Principles of Good Writing (p. 246)
9.2 Types of User Support (p. 249)
9.2.1 On-Line Help (p. 249)
9.2.2 Reference Manuals (p. 251)
9.2.3 Open Discussion Forums (p. 253)
9.2.4 User Training and Feedback (p. 257)
9.3 Example: RMH Homebase On-Line Help (p. 258)
9.3.1 Help and the Code Base (p. 258)
9.4 Summary (p. 263)
Exercises (p. 263)
10 Project Governance (p. 265)
10.1 Origins and Evolution (p. 265)
10.1.1 Starting a Client-Oriented Project (p. 267)
10.1.2 Quality Assessment (p. 271)
10.2 Evolving into a Democratic Meritocracy (p. 273)
10.2.1 Incubation (p. 274)
10.2.2 Organization (p. 277)
10.2.3 Decision Making and Conflict Resolution (p. 281)
10.2.4 Domain Constraints (p. 282)
10.3 Releasing Code (p. 284)
10.3.1 Licensing (p. 284)
10.3.2 Finding a Project Host (p. 285)
10.3.3 Release Strategies (p. 287)
10.4 Summary (p. 289)
Exercises (p. 290)
11 New Project Conception (p. 291)
11.1 Requirements Gathering (p. 292)
11.1.1 Domain Analysis (p. 292)
11.1.2 User Stories (p. 295)
11.1.3 Use Cases (p. 297)
11.2 Initial Design (p. 303)
11.2.1 Domain Classes (p. 303)
11.2.2 User Interface (p. 304)
11.2.3 Performance and Platform (p. 305)
11.2.4 System Architecture (p. 307)
11.2.5 Design Alternatives (p. 308)
11.2.6 Design Document (p. 308)
11.3 Summary (p. 309)
Exercises (p. 309)
Appendices (p. 311)
A Details of the Case Study (p. 311)
A.1 Requirements (p. 311)
A.1.1 Domain Analysis (p. 312)
A.1.2 Use Cases (p. 317)
A.1.3 System Requirements (p. 327)
A.2 Design (p. 328)
A.2.1 Goals (p. 329)
A.2.2 Software Architecture (p. 329)
A.2.3 Domain Classes (p. 330)
A.2.4 Database Design (p. 330)
A.2.5 GUI Design (p. 333)
A.2.6 Implementation Schedule (p. 336)
A.2.7 User-System Interaction (p. 336)
B New Features for an Existing Code Base (p. 341)
B.1 Starting with a Request from the Client (p. 341)
B.2 Impact on the Design and the Code Base (p. 343)
B.3 Defining a Project that Implements these Features (p. 350)
References (p. 351)
Index (p. 355)

Author notes provided by Syndetics

Allen B. Tucker is the Anne T. and Robert M. Bass Professor Emeritus at Bowdoin College in Brunswick, Maine. Dr. Tucker is an ACM Fellow and Distinguished Lecturer and a member of the Humanitarian FOSS Project's executive committee. He has published papers in the areas of programming languages, software development, natural language processing, and curriculum development.

Ralph A. Morelli is a professor of computer science at Trinity College in Hartford, Connecticut. Dr. Morelli is one of the principal investigators of the Humanitarian FOSS Project. He has published papers in the areas of artificial intelligence, FOSS, and computer science education.

Chamindra de Silva is the CTO and director of the Sahana Project, which provides a free and open source disaster management system. He is also a co-founder of the Humanitarian FOSS Community and an advisory board member of the Humanitarian FOSS Project. He has participated in many governmental and NGO projects in Pakistan, the Philippines, Peru, the United States, China, and Haiti.

For more information on the Humanitarian FOSS Project, visit its website.