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.
To fulfill the demand for quickly locating and searching documents.
It is intelligent file search solution for home and business.
Related download
- ap computer science a pitt
- cpsc 101 introduction to computers
- cop2210 programming i
- department of mathematics and computer science
- flying start a level psychology
- edexcel gcse in computer science lesson activities for
- curriculum design template
- ap computer science ab
- computer science 3 a required course on client
- microsoft word computer science transition task 2019
Related searches
- department of wages and labor
- department of public and social services
- department of education and accreditation
- colorado department of health and human services
- department of budget and finance
- biology and computer science careers
- pa department of labor and industry
- department of education and training
- new york department of banking and insurance
- department of banking and insurance nj
- department of elementary and secondary ed
- colorado department of health and environment