DEPARTMENT OF MATHEMATICS AND COMPUTER SCIENCE …



DEPARTMENT OF MATHEMATICS AND COMPUTER SCIENCE

COPPIN STATE COLLEGE

(Tentative) SYLLABUS – FALL 2005

COSC 409: Software Engineering (3 cr.)

Instructor Sisir Ray, Ph.D. Office GJ 611

Telephone (410) 951-3463 Email: sray@coppin.edu

Web Site (Use Browser: Internet Explorer Only)

Class Time: MW: 1:00 – 1:50 PM

F: 2:00 – 2:50 PM

Location GJ 218

Office Hours MTWR: 9:30 AM – 12 PM

MTWR: 2:00 PM – 3:00 PM

Other Time: By Appointment

FINAL EXAM DATE & TIME

Friday, 12/16/2004 between 12:00-1:50 PM.

________________________________________________________________________

Required Text(s)

Classical and Object-Oriented Software Engineering, Sixth Edition by Stephen R. Schach; McGraw-Hill.

Optional Text

UML Distilled, Second Edition by Fowler with Scott; Addison-Wesley, 1999.

Other Requirements Students should provide sufficient number of floppy disks (CDs are preferable) for class projects and assignments. Also, keep reserve at least one USB Memory Stick (removable disk).

Tegrity pen and notebooks, if instructor decides to use Tegrity technology in the classroom.

Catalog Course Description:

COSC 409 Software Engineering (3 credits)

An overview of the techniques involved in the creation and maintenance of software. The course treats object-oriented design and emphasizes sound programming concepts, including classes, abstract data types, objects, inheritance, encapsulation, and polymorphism. Prerequisite: COSC 302.

Course Learning Objectives and Students Competencies upon Completion:

The course will discussed topics mainly from four areas of Software Engineering:

1. The Product and Process

2. Managing Software Projects

3. Conventional Methods for Software Engineering

4. Object-Oriented Software Engineering

The main focus of the course will be to develop software using the principle of Object-Oriented approach of Software Development Process.

Upon completion of this course, students will learn the following materials and have the following competencies:

1. Fundamental goals of software engineering

2. Concepts of the product and process

3. Software life-cycle models - analysis, specifications, design, coding, testing, and maintenance phases of software development

4. Acquaintance with the Classical approach and Object-Oriented approach of Software Engineering

5. Concept of software project planning, risk management, quality assurance

6. Developing a complete project using any Object-Oriented high-level language (C++,or Java) phase by phase in both Classical and Object-Oriented approaches of Software Engineering

7. Acquaintance with the Unified Modeling Language (UML) in Object-Oriented approach

8. Acquaintance with CASE (Computer-Aided Software Engineering) tools in Object-Oriented approach.

Students will clearly be able to understand the shortfall and glitch existing in today's software development system. Students will be able to understand and learn the systematic and methodical approaches of software development and the requirements of scientific and engineering principles of software development. Students will be well prepared for future study in computer science and ready to apply their knowledge to software engineering projects, in an academic program, or in the workplace.

Modes of Evaluation:

Quizzes 10%

Tests (at least two): 20%

Final exam: 20%

Homework & Projects 45%

In-class participation &

Attendance 5%

Homework problems will be assigned from the textbook chapters and may include at least one related paper review. The class project will be conducted in several phases that will be discussed in the class in appropriate time. The project will be a team effort. However, the contribution of an individual team member in the project development will be the basis of grading for that individual. Submission of projects within the due time is very important for software development. Projects submitted after the deadline will be docked 10% per week.

Grading Scale:

Cutoffs for A, B, C, and D will not be higher than 90%, 80%, 70%, and 60%, respectively.

Attendance Policy:

Regular and punctual attendance is required. The College policy will be strictly adhered to--i.e, a maximum of six unexcused absences is allowed for a three credit course, four for a two credit course, and two for a one credit course.

College-wide writing Standards:

The Mathematics/Computer Science adheres to the College's policies on writing standards.

Plagiarism Policy:

It will be taken for granted that any work that a student does for this course is her/his original work. Any violation of this rule constitutes plagiarism. Plagiarism includes any form of cheating on examinations, tests, or quizzes, or any unacknowledged/undocumented use of another's writings or ideas, published or unpublished. A student who plagiarizes will receive an F for the project.

Bibliography:

1. Classical and Object-Oriented Software Engineering, Fifth & Sixth Edition by Stephen R. Schach; McGraw-Hill.

2. Classical and Object-Oriented Software Engineering With UML and Java, Fourth Edition by Stephen R. Schach; McGraw-Hill, 1999.

3. Software Engineering - A Practitioner's Approach. Sixth Edition by Roger S. Pressman; The McGraw-Hill Co., Inc. 2001. ISBN 0-07-365578-3

4. Software Engineering - A Practitioner's Approach. Fifth Edition by Roger S. Pressman; The McGraw-Hill Co., Inc. 1997.

5. Software Engineering - A Beginner’s Guide by Roger S. Pressman; The McGraw-Hill Co., Inc. 1988.

6. Software Engineering, 6th Edition by Ian Sommerville; Addison-Wesley, 2001.

7. The Unified Software Development Process by Jacobson, Booch, Rumbaugh; Addison-Wesley, 1999.

8. Class Notes that posted on Instructor’s Web Site.

9. Visual Modeling with Rational Rose 2000 And UML by Terry Quatrani. Addison-Wesley, 2000.

10. Object-Oriented Software Engineering Conquering Complex and Changing Systems by Bernd Bruegge and Allen H Dutoit. Prentice Hall, 2000.

11. Requirements Analysis And System Design – Developing Information Systems with UML by Leszek A Maciaszek. Addison-Wesley, 2001.

12. Software Engineering Theory and Practice, 2nd ed., by Shari Lawrence Pfleeger. Prentice Hall, 2001.

13. The Engineering of Software – Technical Foundations for the Individual by Dick Hamlet and Joe Maybee. Addison-Wesley, 2001.

14. An Introduction to Object-Oriented Analysis Objects in Plain English by David Brown. John Wiley, 1997.

COSC 409

(Tentative) COURSE OUTLINE and PROJECT TASKS

MODULE 1: Overview and Scope of Software Engineering

Definition of good software

- Software is engineered and not manufactured

- Software doe’s not wear out

- Most software still continues to be custom built

Broad Categories of software

- System software, Application software, Engineering/Scientific software, Embedded software, Product-line software, web-applications, AI software

Understanding of new challenges due to Wireless networking, Netsourcing, Open source applications.

Software Evolution

Definition and Scope of software Engineering

Five different aspects of software Engineering

- Historical Aspects

- Economic Aspects

- Maintenace Aspects

- Specification and Design aspects

- Team-Programming Aspects

Overview of Structured Paradigm and Object-Oriented Paradigm.

Understanding of

Action Oriented approach

Data Oriented approach

Object-Oriented approach (both action and data oriented)

Revisit the concept of Object-Oriented Paradigm

- Encapsulation

- Polymorphism

- Inheritance

- Reusability

MODULE 2: The Software Process and Process Models

Importance of 3-P’s: Product, Process, and People

Importance of Software process and phase-concept of software development (Life-cycle)

Software Life-Cycle Models – their pros and cons

Conventional Models

- Code-and-Fix Model

- Waterfall Model

- Rapid Prototyping Model

- RAD Model

- Incremental Model

- Spiral Model

Specialized Models

- Extreme Programming (Agile Development)

- Component-Based Development

- The Formal Methods

- Object-Oriented Life-cycle Models and Unified Process models

MODULE 3: Requirements Phase/Workflows

During this time of study, students are asked to form a project team. Students will work in team environment. Each team will select its team name and team project. Each team is asked to submit a one page of outline of its project for instructor’s approval. Instructor will act as a client.

In this phase, students will learn the various tasks of requirements for understanding what customer (client) wants and what customer needs

- Steps of Requirements Elicitation

- Steps of Requirements Analysis

UML notations for Use Case Modeling

Understanding of Stepwise Refinements

CASE TOOLS: ArgoUML and other freeware, shareware, and professional CASE tools

CASE STUDIES.

Also, during this time each project team is required to develop and submit the Deliverable 1: Requirements Workflows.

Deliverable 1: Requirements Workflows

Submit the deliverable as a formal report in type format. Setup consultation meetings between members and keep the records of all meetings. Keep the records of all individual activities (plus times). Select a leader for this deliverable. To prepare the main activities of this deliverable, consult “The Osbert Oglesby Case Study”, Chapter 10 of your textbook. Each member should develop the description of at least one of your system use cases.

The deliverable should contain the followings:

i) A cover page

ii) Table of contents

iii) Task assignments among team members

iv) Main Activities:

1. The outline of the project that you developed earlier

2. The Initial Use Case model using UML notations

3. The Glossary Table, if any

4. The final refinement of all use case descriptions

5. Activity Log: as explained in class

6. Works Cited, if any

7. Appendix: Any work that you think will help you understand the product better in future (e.g. step-by-step refinement of use cases)

MODULE 4: Project Estimation, Scheduling, and Risk Management

Project Estimation

Various Process and Project metrics (LOC, FP, Use-case Oriented)

LOC-Based Estimation

Function Point-Based Estimation

Empirical Model-Based Estimation

History and various empirical models

The COCOMO II Model

Scheduling

- Gantt Chart

- CPM Chart

Risk Management

Types of Risks (Technical Risk, Product Risk, Process Risk, etc)

Risk Identification

Risk Estimation (Probability, Consequences, and Impact of each risk)

Risk Mitigation, Monitoring, and Management

During this time each project team is required to develop and submit the Deliverable 2: Project Estimation, Scheduling, and Risk Analysis

DELIVERABLE 2 - Project Estimation, Scheduling, and Risk Analysis

NOTE: The attached Project Planning document (a sample document may be supplied in the class) is just a sample. Do not copy the materials. Many things are there, which you may not require to produce. Write appropriately what is needed to develop your product. Minimum requirements are as follows:

1. Project Estimates

- Calculate FP (Function Point)

- Estimate Effort (E) and Duration (D) using COCOMO Basic (organic) model

NOTE: You already know duration of your project time and man power. Also, note that you are not a full-timer to work with this project.

2. Risk Analysis (See the format described in the sample)

3. Scheduling

- Gantt Chart (must)

- CPM Chart (optional)

4. Project Resources (People, hardware, software)

5. Activity Log (updated)

Organization of the Deliverable 2

1. Title Page (you may design with graphics)

2. Work Assignments (Member names, the job a member did for this deliverable) page

3. Table of Contents

4. All materials as described above

5. Appendix, if any

MODULE 5: Structured (Classical) Analysis and Object-Oriented Analysis Phase

Overview of the Structured Analysis Model:

Data Model: Entity Relation Diagram (ERD)

- Relationships

- Cardinality & Modality

Functional Model: Data Flow Diagram (DFD)

Behavioral Model : State Transition Diagram (STD)

Identifying Data (objects and attributes) and functions

- Using Noun-and-Verb methods

Object-Oriented Analysis

(1) Functional Modeling – Use-Case modeling

Concepts of classes/objects

(2) Class Modeling

Entity Classes

Boundary Classes

Control Classes

Identifying Classes:

Revisit the Noun-and-Verb method to identify Classes/Objects

Various types of objects or entities

- External entities, things, events, roles, places, organizational units, structures

How to determine candidate classes from potential classes?

CRC (Class-Responsibility-Collaborator) Modeling

Responsibilities (Operations and Attributes)

Basic guidelines to identify class responsibilities

Identifying a class collaborators

Collaboration identify relationships between classes

Various relationships:

▪ is-part-of relationship

▪ has-knowledge-of relationship

▪ depends-upon relationship

Overview of UML and UML notations for

- Class Diagrams

(3) Dynamic Modeling and its purposes

Sequence Diagram using UML notations

State Chart Diagram using UML notations

Other Diagrams

CASE STUDIES

In this phase, each project team will develop and submit the Deliverable 3: Requirements Analysis and Specifications

Deliverable 3: Requirements Analysis and Specifications

(Structured Analysis & Object-Oriented Analysis)

A cover page

Table of contents

Task assignments among team members

1. INTRODUCTION

- Overall description of the Project (if you modify your previous description)

2. Classical or Structure Analysis

Draw Entity Relation Diagram(s) (ERD)

3. Object Oriented Analysis

- Functional Modeling: Present scenarios or event flows of all use cases (from the initial use case models)

- Class Modeling: Draw Initial Class Diagrams (Entity classes, Boundary Classes, and Control Classes) showing names of classes and their attributes

- Using Noun method

- Using CRC card method

- Dynamic Modeling:

- Draw the Sequence Diagram

- Draw the State Chart Diagram

4. Expand the Use Case Models with all functionalities (that you may identify from the first iteration)

5. Finalize the Class Diagram with all classes names and attributes

6. UPDATED SCHEDULE and ACTIVITY LOG

- Gannt Chart

- Activity Log

7. Works Cited

Appendixes

MODULE 6: Design Phase/Workflow

(Classical and Object-Oriented Design)

Transforming Analysis Model to Design Model - Relationships

Design Concepts

Abstraction

Architecture

Modularity

Fan-out and Fan-in

Functional Independence

- Cohesion and Coupling

Information Hiding

Structure Chart

Detailed Design of Modules:

Tabular Format

PDL format: Final

Using Stepwise Refinement of Modules

Detailed Class Diagrams

Detailed Design of each class (Appendix I)

MODULE 7: Software Testing

Overview of Software Testing

Verification and Validation

Concepts of Black Box and White-Box Testing

White-Box Testing (Glass-box testing)

- Basis Path Testing (Unit Testing)

- Determining Cyclomatic Complexity and Independent Paths

- Test cases and Applications

Overview of Object-Oriented Testing Methods

Combining the knowledge of two modules (6 & 7), each project team will develop and submit the Deliverable 4: Design Phase/Workflow

Deliverable 4: Design Workflow

Requirements for Deliverable 4

PART 1: Revisit the “Requirement Analysis Workflow” and modify, if necessary (Due date: Nov.15, 2004 or earlier).

PART II: Design Workflow (Due date: Dec.03, 2004 or earlier)

1. Classical Design Approach: A Structure Chart (textbook page: 401)

2. Overall (Final) Class Diagram using UML notations of Entity class, Boundary class, and Control Class as shown in your textbook, p.413.

3. Overall (Final) Class Diagram using UML notations showing attributes and operations of each classes and their relationships (p.414).

Detailed Design:

- Write PDL (program specific) for each operation of each class.

Testing and Validation of Control Structure (each team member should test at least one method that has logical structure)

- Draw flowcharts of the operations that have logical control structures

- Perform the Complexity Test for each flowchart or control structure

NOTE:

1. Include other standard materials: cover page, member’s assignment, Gantt Chart, activity log, etc.

2. Activity diagram and State Chart diagram are optional.

3. Start working parallel for Part I, II, and Deliverable 5, which is the Implementation Workflow (Coding)

MODULE 8: Miscellenious

(a) Implementation Phase: If required refresh C++, Java, etc.

Deliverable 5

Using your choice of programming language(s), complete writing code of your project. Run and test. Every member of each team should write a portion of project code and identify with member’s name appropriately.

Finally submit your source codes of your team project both in hardcopies and in disks (a CD preferable). Also include the final versions of your all deliverables in that CD.

(b) Overview of User Interface

(c) Others

NOTE: Besides team deliverables, students are required to complete several homework assignments on individual basis.

Deliverable 6

All team will present their projects in the class after the completion of your team projects.

Generally, all presentations will be scheduled in the last week of the semester (before the final exam week).

................
................

In order to avoid copyright disputes, this page is only a partial summary.

Google Online Preview   Download