courses+outcomes+assessments 1

8/21/2019 Courses+Outcomes+Assessments 1

1/64

1

Computer Science Course Descriptions

including

Course Outcomes

Assessment Plans

Course Improvements


2/64

2

COURSE DESCRIPTION

Department and Course

Number

Com S 227 Coordinators

Fall 2008

James Lathrop, Steve

Kautz, Pavan Aduri

Course Title Introduction to object-oriented Programming Total Credits 4

Current Catalog Description(3-2) Cr. 4. F.S. An introduction to object-oriented design and programming

techniques. Symbolic and numerical computation. Recursion and iteration. Modularity, procedural and data

abstraction, specifications and subtyping. Object-oriented techniques. Imperative programming. Emphasis

on principles of programming and object-oriented design through extensive practice in design, writing,running, debugging, and reasoning about programs. This course is designed for majors. Credit may not be

applied toward graduation for both 207 and 227.

Textbook James Cohoon and Jack Davidson,Java 5.0 Program Design

Coordinators James Lathrop, Senior Lecturer,Steve Kautz, Lecturer

Pavan Aduri, Associate Professor

Course OutcomesAt the end of Com S 227 the students should be able to:

Write, debug, and document well-structured Java applications of up to 500 lines Implement Java classes from specifications Effectively create and use objects from predefined class libraries Understand the behavior of primitive data types, object references, and arrays Use decision and iteration control structures to implement algorithms Write simple recursive algorithms Use interfaces, inheritance, and polymorphism as programming techniques Use exceptions

Relationship between Course outcomes and Program outcomes: B, C

Prerequisite (s) by TopicHigh school algebra and geometry

Major Topics covered in the Course

Managing files; using an integrated development environment Objects, classes, methods, fields, and constructors Primitive types and references Arithmetic expressions, String operations Overview of the software engineering process

Unit testing with the JUnit framework Conditional statements and Boolean expressions Iteration Basic console and text file I/O One-and two-dimensional arrays Using a symbolic debugger Designing with interfaces Inheritance, polymorphism, abstract classes Exceptions and exception handling


3/64

3

Recursion Searching and sorting

Laboratory exercises

A. Programming projects

Normally five individual-effort projects are assigned throughout the semester, with increasing levels of

difficulty.

B. Laboratory activities

1. Files; the Eclipse IDE2. Java API documentation; the Javadoc tool; creating a simple class3. String manipulation; evaluating expressions4. Interacting classes; Boolean expressions5. Command-line tools and shell commands6. Code style and formatting7. The Eclipse debugger8. Exception handling; File I/O9. JUnit10. Inheritance and polymorphism; creating Exception types11. Recursion

Assessment Plan for the Course

Outcome How Measured When Measured

Improvements

Identified

Improvements

Implemented

Write, debug,

and documentwell-structured

Javaapplications of

up to 500 lines

(B, C)

Evaluation of

programming projects

Every semester Students tend to

postpone reviewingand learning new

material until justprior to project

deadlines.

Implement a series of

structured hands-onlaboratory exercises for

new and/or difficulttopics to ensure

students absorb them

well before needed forprojects.

Implement Java

classes from

specifications

(C)

Exams; evaluation of


Every semester Students fail to

grasp the role of

specifications in

implementing

components of asystem.

Make sure that one or

more of the


involves integration of

student-implementedclasses with existing

libraries.

Use interfaces,inheritance, and

polymorphism

as programmingtechniques (B)

Performance ofcontinuing students at

start of Com S 228;

exams; evaluation ofprogramming projects

Every semester Students fail tocomprehend the

use of interfaces in

a design.

Include laboratoryexercises using

interfaces and

inheritance. Ensurethat one or more of the


requires students to

program withinterfaces.


4/64

4

How Data in the Course is used to assess Program Outcomes

Assessment data from each course is given to the departments undergraduate committee. A detailed description of

how this data is used to assess program outcomes is provided in Appendix A, the departments Learning Outcomesand Assessment Plan.

Curriculum Category Content (Semester Hours)

CORE ADVANCED CORE ADVANCED

Algorithms

Computer Organization and

Architecture

Data Structures

Concepts of Programming

Languages 2

Software Design 2


5/64

5

COURSE DESCRIPTION


Number

Com S 228 Course Coordinator

Fall 2008

James Lathrop

Course Title Introduction to Data Structures Total Credits 3

Current Catalog Description (3-1) Cr. 3. F.S. Prereq: C- or better in 227, credit or enrollment in Math 165. An

object-oriented approach to data structures and algorithms. Object-oriented analysis, design, and programming, withemphasis on data abstraction, inheritance and subtype polymorphism. Abstract data type specification and

correctness. Collections and associated algorithms, such as stacks, queues, lists, trees. Searching and sorting

algorithms. Graphs. Data on secondary storage. Analysis of algorithms. Emphasis on object-oriented design, writingand documenting medium-sized programs. This course is designed for majors.

Textbook William J Collins,Data Structures and the Java Collections Framework, Second Edition, McGraw Hill2005. ISBN: 0-07-282379-8

Coordinators James Lathrop, Senior Lecturer

Course Outcomes At the end of ComS 228, the students should: be able to write well-structured object-oriented programs of up to 1000 lines of code; understand type safety and use of generic types to enforce type safety; be able to write programs and class libraries given a specification; understand Big-O notation and apply it to simple methods, including methods that utilize complex loops

and recursion;

analyze run-time execution of previous learned sorting methods, including selection and merge sort; implement and analyze insertion sort and Quicksort sorting algorithms; understand abstract data types and how they are implemented in an object-oriented language; understand and implement the List Abstract Data Type (ADT) using both array based and linked-list based

data structures, including singly, doubly, and circular linked-lists;

understand and implement the Stack ADT using both array based and linked-list based data structures; understand and implement the Queue ADT using both array based circular queue and linked-list based

implementations; understand and implement priority based queues; understand and implement general tree data structures, including binary tree, both array based and

reference based implementations;

understand and implement binary search trees; understand and implement heaps using an array based tree data structure; understand and analyze heapsort; understand and implement graph data structures; understand and implement various algorithms on graph data structures, including finding the minimum

spanning tree and shortest path;

understand and implement hash table data structures and understand the map abstract data type; evaluate the runtime of operations such as add and delete on data structures covered in the class.

Relationship between Course Outcomes and Program Outcomes: A, B, C

Prerequisite by Topic

Programming in an object-oriented programming language that include instruction with topics equivalent to

those covered in ComS 227.

Credit or enrollment in first semester calculus.


6/64

6

Major Topics Covered in the Course

Topic Reading from text

CS 227 review Ch 1, 2

Runtime Analysis Ch 3Sorting Algorithms Ch 5, 11

Collection Interface and Iterators Ch 4

Lists and the ArrayList class Ch 6

Lists and linked lists Ch 7Stacks and Queues Ch 8

Trees Ch 9

Binary Search Trees Ch 10Tree Set Interface Ch 12

Hash Tables Ch 14

Graphs and Graph Algorithms Ch 15

Programming Assignments

There are typically 5 programming assignments spaced approximately 3 weeks apart.

Assignment 1: This assignment is comprised of material mostly from ComS 227, but also includes some generic

typing. It is designed to be a slightly bigger project than projects completed in ComS 227 with emphasis placed on

integrating several different concepts from ComS 227 into a single program. Program documentation, design, andprogramming style are graded. Unit testing is also reviewed and required in this assignment.

Assignment 2: This assignment gives students practice in designing and implementing various sorting methods,

including Quicksort and then measuring the number of CPU cycles required to sort random data sets of various

sizes. The students are required to graph their results to understand the relationship between data set size and

execution time of the various algorithms. Students are encouraged to write their own test data sets and share withthe class.

Assignment 3: In this assignment students must implement a substantial Java interface, typically the List interface.Students are required to code according the specification and their implementation must match that of one of Suns

implementations. (This allows students to continually check their work against the correct answer.) In order to keep

students from downloading source code and not learning how to manipulate linked list or array lists, restrictions areplaced on the implementation. For example, instead of implementing a list using a standard doubly linked-list, the

implementation must create list nodes that skip 2 forward and 3 back.

Assignment 4: This assignment typically requires students to write a complete program that requires manipulating a

tree structure. Past programs include writing a compression and decompression methods for the Lempel-Zivcompression algorithm, implementing a simple interpreter for a made-up programming language, and implementing

a trinary search tree. It is encouraged that instructors try to create and assignment that encompasses and solves some

aspect of a real-world problem.

Assignment 5: This assignment consists of two parts, one mandatory and one optional. The mandatory part testsstudents ability to implement a graph structure and compute some properties of the graph such as shortest path orconnectedness. In addition, the students are given an interface that allows them to control a virtual robot that roams

the galaxy by traversing wormholes in a game environment. Systems and wormholes form a weighted directed

graph and thus graph algorithms may be useful in defeating the opponent. Students are required to write a basic

robot that wins against inept computer controlled robot. In addition, students may optionally enter a tournament

where their robots are played against each other on the last day of class.


7/64

7



Improvements

Identified

Improvements

Implemented

Write, debug,and document

well-structured

Java

applications ofup to 1000 lines

Evaluation ofprogramming projects

Every semester Students aresurprised by the

difference in size in

the programming

projects required inCom S 228 and

ComS 227. This

leads to students

startingassignments late

and not finishing

them.

Assignments are givenearly to students with

explanations on how

long the assignment can

take. Electronicbulletin boards are used

for student discussion

of assignment.

Implement Java

classes from

specifications

Exams; evaluation of


Every semester Students fail to

grasp the role of

specifications in

implementingcomponents of a

system.

Assignment 3 requires

students to completely

implement the List

interface in the Javacollection package

using an uncommon

backing data structure.Other assignments

include significant

specification that

require students to readand understand them in

order to complete the

project with a good

score.

Lack of

retention ofprerequisite

material.

Exams, programming

projects, and studentclass interaction.

Every semester Students need to

understandconcepts from

ComS 227in order

to do well in ComS

228.

Two days of lecture

devoted to reviewingmaterial from Com S

227 with emphasis

placed on topics the

students themselves

believe they do notunderstand. The first

assignment includes

only a few new ideastogether with

requirements that force

students to use much of

the topics covered in

ComS 227.



how this data is used to assess program outcomes is provided in Appendix A, the departments Learning Outcomes

and Assessment Plan.


8/64

8



Algorithms 0.5


Architecture

Data Structures 2


Languages

Software Design 0.5


9/64

9

COURSE DESCRIPTION


Number


Fall 2008

James Lathrop

Course Title Advanced Programming Techniques Total Credits 3

Current Catalog Description (3-0) Cr. 3. F.S. Prereq: 228, credit or enrollment in Math 166. Object-oriented

programming experience using a language suitable for exploring advanced topics in programming. Topics includememory management, parameter passing, inheritance, compiling, debugging, and maintaining programs. Significant

programming projects.

Textbook (optional) Bjarne Stroustrup, The C++ Programming Language, Addison-Wesley 2000. ISBN

0201700735. Nicolai M. Josuttis, The C++ Standard Library (A Tutorial and Reference), Addison-Wesley 1999,

ISBN: 0201379260. Kernighan and Ritchie, The C Programming Languagesecond edition, Prentice Hall, 1998.ISBN: 0-13-110362-9

Coordinators James Lathrop, Senior Lecturer

Course Outcomes At the end of ComS 229, the students should: be able to write well-structured complex programs from specifications that may not be precise in OO and

non OO programming languages,

communicate questions to clarify program requirements, understand differences between managed and unmanaged programming languages such as Java and C++ or

C.

understand simple build systems and create software projects that utilize a simple build system to produceseveral target executable programs,

understand how to read and program using the C programming language. understand and utilize memory management techniques for C programming, including allocation and

tracking of dynamically allocated memory,

program and link together elements of Java programs and C programs using the Java native Interface, compare and contrast elements of C programming language (a non OO language) and the Java

programming language, understand how to read and program in the C++ programming language, understand and use C++ templates and the standard template library, understand memory management techniques used in C++ programming, understand memory management techniques used in managed languages such as Java such as mark and

sweep garbage collection algorithms,

understand and program basic elements of a GUI interface.Relationship between Course Outcomes and Program Outcomes: A, B, C


Programming in an object-oriented programming language that include instruction with topics equivalent to

those covered in ComS 227.

Understanding of data structures with topics equivalent to those covered in ComS 228.

Credit or enrollment in second semester calculus.


10/64

10

Major Topics Covered in the Course

Introduction

The C Programming LanguageCompiling C programs

Difference between C and Java

The make programJava GUI concepts using Swing

Java JNI and the C programming language

The C++ programming languageCompiling C++ programs

Differences in C++, Java and C

C++ templates and the STL

Memory management

Multiprogramming and threads in Java and C++

Programming Assignments

There are typically 2 large programming assignments during the semester.

Assignment 1: Assignment 1 is includes aspects that requires the student to program a significant project in the Cprogramming language with interfaces with the Java programming language. Topics required to complete project

include C programming, C memory management, Java JNI interface, the make system, and correctly compiling C

programs (using the make system). Extensive use of data structures and concepts from ComS 227 and ComS 228

are required in order to satisfactorily complete the assignment.

Assignment 2: Assignment 2 includes aspects that requires the student to program a significant project in C++. Thestudent may be required to interface with C and Java to complete the assignment. Use of templates and data

structures using templates may be required.



Improvements

Identified

Improvements

Implemented

ALL Evaluation of class atend of the semester

Every semester Students wouldbenefit greatly

from a recitation

(even optional) forthis class so that

there is time set

aside other than

lecture wherestudents can get

help.

Addition of recitationsection to ComS 229.

(not yet implemented)

Design and

program well-structured

complexprograms

Evaluation of


Every semester Students have

difficultiesdesigning and

assembling a largecomplex project

given a list of

complex

interrelated

requirements.

Complex assignment

requirements arepresented as in

organized units for thestudents with separate

implementations that

can then be linked

together in the final

project.


11/64

11







Algorithms 1.0


Architecture

Data Structures 1.0Concepts of ProgrammingLanguages

0.5

Software Design 0.5


12/64

12

COURSE DESCRIPTION


Number

Cpr E 281 Course Coordinator

Fall 2008

Ahmed Kamal

Course Title Digital Logic Total Credits 4

Current Catalog Description(3-2) Cr. 4. F.S. Prereq: sophomore classification. Number systems and

representation. Boolean algebra and logic minimization. Combinational and sequential logic design. Arithmetic

circuits and finite state machines. Use of programmable logic devices. Introduction to computer-aided schematic

capture systems, simulation tools, and hardware description languages. Design of a simple digital system.

Textbook S. Brown and Z Vranesic, Fundamental of Digital Logic with Verilog Design, McGraw-Hill,

Second Edition, 2008.

Coordinator Ahmed Kamal, Professor of Electrical and Computer Engineering

Course Outcomes

To introduce number systems and codes, and digital representation of data, and to teach the generalconcepts in digital logic design, including logic elements, and their use in combinational and sequential

logic circuit design.

Students will also be introduced to computer-aided schematic capture systems, simulation tools andhardware description languages, and will use programmable logic devices.

Relationship between Course outcomes and Program outcomes:A, C

Prerequisites by Topic

Major Topics covered in the Course1. Introduction(Chapter 1)

o Digital Hardwareo The design processo The design of digital hardware

2. Introduction to Logic Circuits(Chapter 2)o Variables and functionso Inversiono Truth tableso Logic gates and networkso Boolean algebrao Synthesis using AND, OR and NOT gateso NAND and NOR logic networkso Design examples

3. Implementation Technology(Chapter 3)o Transistor switcheso NMOS logic gateso CMOS logic gateso Negative logic systemso Standard chipso Programmable devices

4. Optimized Implementation of Logic Functions(Chapter 4)o Karnaugh mapo Strategy for minimizationo Minimization of product-of-sums formso Incompletely specified functionso Multiple-output circuits


13/64

13

o Multilevel synthesiso Analysis of multilevel circuits

5. Number Representation and Arithmetic Circuits(Chapter 5)

o Positional number representationo Additional unsigned numberso Signed numberso Fast adderso Multiplicationo Other number representationso ASCII character code

6. Combinational-Circuit Building Blocks(Chapter 6)o Multiplexerso Decoderso Encoderso Code converterso Arithmetic comparison circuits

7. Flip-flops, Registers, Counters and a Simple Processor(Chapter 7)

o Basic latcho Gates SR latcho Gated D latcho Master-slave and edge-triggered D flip-flopso T flip-flopso JK flip-flopso Registerso Counterso Reset synchronization

8. Synchronous Sequential Circuits(Chapter 8)o Basic design stepso State assignment problemo Mealy state modelo Serial adder exampleo State minimizationo Design of a counter using the sequential circuit approacho FSM as an arbiter circuito Analysis of synchronous sequential circuitso Algorithmic state machineo Formal model for sequential circuits

9. Digital system Design(Chapter 10)o Building block circuitso Design exampleso Clock synchronization

Important Notes

1. Requesting academic accommodation:Please address any special needs or special accommodations with me at the beginning of the semester or as

soon as you become aware of your needs. Those seeking accommodations based on disabilities should

obtain a Student Academic Accommodation Request (SAAR) form from the Disability Resources (DR)

office (515-294-7220). DR is located in 1076 Student Services Building.2. All class material, including copies of lecture notes, homeworks and their solutions, labs, quiz solutions,and midterm exam solutions will be posted on WebCT. Please check WebCT regularly.

3. Homeworks are due at the beginning of class.4. Quizzes will be at the end of class.5. All quizzes and exams will be held in the classroom.6. Pre-Labsmust be submitted to the TA at the beginning of the lab.7. There are no supplementary or make-up exams in this course.8. There will be no changes in the exams, labs, homeworks and quiz dates. Please refer to the Schedulefor

those dates.


14/64

14

9. No late homework assignments will be accepted.10. Students may discuss the homeworks, and how to solve them. Students are encouraged to use the

Discussion Forum on WebCT (I will be monitoring the forum and will post contributions if needed).

However, the actual solution of the homeworks must be done independently. Students found to be copying

homework assignments, or project codes will be subject to the ISU cheating and plagiarism regulations.11. The instructor and TAs are available to help you during the office hours. Appointments outside the office

hours can also be arranged. Please contact the instruction or the TAs to arrange for appointments.

12. All pagers and cellular telephones must be turned offduring the class time.Thank you for your cooperation.


Outcome

How Measured When Measured Improvements

Identified

Improvements

Implemented

Comprehension of

tradeoffs involved in

design choices (H)

Student performance

on quizzes and

exams which are

graded by the courseinstructor and not the

TAs, senioroutcomes assessmentsurveys

Every semester Students had

difficulties in

formulating

problems incomputer

architecture and thuscould not solve them.

- More in class

examples are worked

out.

- Periodic in-classactivities are

conducted wherestudents work ingroups of two or

three to formulate

and solve problemsin lecture.

Comprehension of

memory tradeoffsand management

policies

Performance on

quizzes andhomework

Every semester Students seemed to

have differentlearning strategies

for these concepts

A visual hands-on

Java tutorial isavailable for students

who are visual

learners.


Assessment data from each course is given to the departments undergraduate committee. A detailed description ofhow this data is used to assess program outcomes is provided in Appendix A, the departments Learning Outcomes




AlgorithmsComputer Organization andArchitecture 2

Data StructuresConcepts of ProgrammingLanguages 1

Software Design


15/64

15

COURSE DESCRIPTION


Number

Com S 309 Course Instructor

Fall 2008

Simanta Mitra

Course Title Software Development Practices Total Credits 3

Current Catalog Description(3-1) Cr. 3. F.S. Prereq: Com S 228 with C- or better, Com S 229 or Cpr E 211, Engl

250. A practical introduction to methods for managing software development. Process models, requirements

analysis, structured and object-oriented design, coding, testing, maintenance, cost and schedule estimation, metrics.

Programming projects. Nonmajor graduate credit.

Textbook Eric J. Braude, Software Engineering: An Object Oriented Perspective, John Wiley and Sons Inc., ISBN

0-471-32208-3.Reference

Software Engineering, Ian Sommerville, Addison-Wesley, 6th edition, 2001. An Integrated Approach to Software Engineeringby Pankaj Jalote, 2ndEdition. Software Engineeringby Shari Pfleeger. UML Toolkitby Hans-erik Eriksson and Magnus Penker.

Coordinators Robyn Lutz, Professor

Simanta Mitra, Senior Lecturer

Course OutcomesTo introduce the students to the major software engineering topics and position them to leadmedium-sized software projects in industry.

1. Students will learn to work as a team and to focus on getting a working project done on time with eachstudent being held accountable for their part of the project.

2. Students will learn about risk management and quick prototyping to de-risk projects.3. Students will learn about and go through the software development cycle with emphasis on different

processes - requirements, design, and implementation phases.

4. Students will learn details about different artifacts produced during software development.5. Students will learn about different software development process models and how to choose an appropriate

one for a project.

6. Students will gain confidence at having conceptualized, designed, and implemented a working, mediumsized project with their team.

Relationship between Course Outcomes and Program Outcomes: A, B, C, D, E, F, G, H, I, J, K


1. A high-level programming language.2. Data structures.

3. Proficiency in written English.


16/64

16

Major Topics covered in the course

1. Intimate familiarity with various software artifacts (documents/code) produced during a software developmentproject.

2. Top Issues in Software Engineering3. Project Management: Process Models, Planning, Scheduling, Cost Estimation, Risk Management, Metrics,

Project execution, Project termination.4. Software Requirements: Elicitation, Specification, Verification, Validation.5. Software Architecture: Decomposition, Modularity, Specification of Interfaces, Design tradeoffs, Design

Evaluation.

6. Configuration Management: Use of source control tools, change management.7. Testing techniques, Inspections/Reviews.

Laboratory ProjectsSemester project introduced first week, due last week: 16 weeks.

One large software development project lasting the entire semester. Artifacts developed include:

Project proposal Screenshots/Interface prototyping SRS-1 (Customer Requirements) SRS-2 (Developer Requirements) DD-1 (Design Decomposition into modules + processes/threads) DD-2 (Module interfaces) DD-3 (Design rationale, Design evaluation) Test Plan Lessons Learnt from project. Working Project Code and Test Codes. Project Poster

Team participation is carefully monitored throughout the semester in a variety of ways:

Minutes of each meeting are collected using a template.

Artifact Work distribution form is collected using a template. Source Control tools are used to gather information on what each team member worked on, on what dates

etc.

During final demo and also in-class status and prototype demonstrations, each team member is grilled onhis/her specific contribution.

Teams have to maintain a portfolio of these artifacts (both hardcopy and softcopy under revision control).

There are several project status update and prototype demonstration sessions throughout the semester. There is afinal project demonstration to the TAs and also a Best Project awards session where the best teams show off their

project to the class.

Each artifact goes through two rounds of submission. In the first round, feedback is provided. In the second round, a

final grade is provided.


This course is unique (given that it is a project course) in that it has an impact on each of the Program Learningoutcomes from A to I!

These outcomes are measured/improved several times during the semester via:

in-class quizzes in-class group activities in-class prototype and design presentations


17/64

17

in-class question/answer and discussion sessions Interviews with individual teams about design Project demonstrations Having students explain their contribution and lessons learnt The project artifacts including minutes of meetings and work-distribution forms.

Several improvements were identified and implemented and each of these applies to multiple program outcomes.

Outcome How

Measured

When

Measured

Improvements

identified

Improvements Implemented

Team Work(course

outcome #1)

1) Workdistribution

forms that

students haveto submit

along with

every artifact.

2) Code logs

fromsubversion

source control

tool.

At eachsubmission

and also at the

end of thesemester.

Team memberproblems:

- some drop- some dont

work at all

- some dontdo coding

- some dontdo docs

A huge emphasis is also placed onhow important team work is towards

success of projects.

Team work etiquette isexplained.

Minutes of meetings arerequired!

For each team submission(there are 10 of them), workdistribution forms have to be

submitted.

Teams are encouraged tolook out for warning signs of

bad team work.

Source control tool(Subversion) is used from

early in the semester and

monitored by the TAs andthe instructor for signs of

some students not working.

Accountability is drummedin. Students have to markwhich parts of eachdocument was created by

them. Similarly, source

control tools indicate whichparts of code are developed

by a specific student.

In the case that somestudents drop modular

design helps to minimize t

he impact. Poor workers aregiven peripheral pieces so

that if they do not completetheir parts the entire project

is not jeopardized.

Risk

Management(course

outcome #2)

Project

artifactsubmission

Several times

during thesemester (at

maximum two

weeksintervals)

Many times, teams

do not get startedearly enough and

then the quality of

the software artifactssuffers. In addition,

they are faced with a

lot of word during

The entire documentation work is

broken up into several increments. Forexample, the SRS is broken into SRS-

1 and SRS-2. Similarly, the SDD is

broken into SDD-1, SDD-2, andSDD-3. With about two weeks for

each document, students have to keep

working on them throughout the


18/64

18

Outcome How

Measured

When

Measured

Improvements

identified


the dead week and

this affects their

grades in other

courses as well.

semester and this helps to create better

documents.

In terms of coding, a huge emphasis is

put on early prototyping right fromday one! Students are encouraged to

create small working fragments of

code and play with networking andthreading and databases and GUI etc.

This way the major technical risks

of projects are encountered early andthen can be addressed early on.

The demos are scheduled the week

BEFORE the dead week. This forces

students to start work real early. Also it then gives them breathing time

during the dead week to focus on

other courses and also the final exam.

Experiencing

software

developmentlifecycle

processes

(course

outcome #3)

Project

artifact

submission

Final project

report with

lessons learnt.

Several times

during the

semester (atmaximum two

weeks

intervals)

Doing the project +

all the documentation

is a LOT of workand sometimes teams

seem jaded and

overworked just by

the thought of it.

Maintaining enthusiasm and

motivation is an important aspect of

projects like this. Several things aredone towards this:

The semester is started with adisplay of posters from

previous semesters. Thesefull-size posters have

information about the

features, the design, lessons

learnt, and students pictures.

There is a lot of excitement

right from the very start. Atthe end of the semester

students create their ownposters and this is added to

the set of existing posters.

Healthy competition betweenteams is encouraged. A best

team project award and a

best documentation award isgiven at the end of the

semester. These are

certificates and signed by thedepartment chair and the

course instructor. There is a best projects

presentation at the end of the

semester - where somefaculty members are also

invited to attend. Students

get to vote for the bestproject in their eyes

although the final


19/64

19

Outcome How

Measured

When

Measured

Improvements

identified


determination is made by the

instructor.

Another important improvement is to

lessen the amount of documentation while still teaching the important

concepts in creating the SRS and SDD

documents. This is achieved bylimiting the work to be done by each

student (for example each student

needs to elaborate and write detailedrequirements for only two features).

Learn details

of softwareartifacts

(course

outcome #4)

Design

documents

Middle of

semester, andEnd of

semester.

Poor quality

Architecturaldocuments were

being submitted.

At this level, students had never

designed anything. They had no ideaof architecture. It was thus impossible

for them to submit good architectural

docs before coding. Instead, I startedto have them complete the final

architectural documentation AFTER

all code is done allowing them to

reverse-engineer and refactor their

code. This experience will allow themto create better architectural

documents in the future also.

Learn about

process

models

(courseoutcome #5)

questions in

class +

final exams

Several times

during

semester , and

End ofsemester

Learning about

processes and

process models is

sometimes tedious for specially students

without internship

experiences.

A lot of time is spent on explaining

why it is important to learn about

these. For example, following best

practices and using tools such asdefect tracking and issue tracking is

important for auditing purposes and to

establish that due diligence was

followed and that can help in legalissues. Examples from industry is

used to motivate students.

Goodworking

projects at

end of

semester(course

outcome #6)

in-classpresentations

during

semester

project demo

at end of

semester

Several timesduring

semester, and

End of

semester

Team projects wereeither too ambitious

or too simple. Either

case is detrimental to

the students learningexperience in the

class.

Teams have to submit three proposalsalong with their evaluations about the

complexity of each project. The

instructor does a separate evaluation

and either adds features or trimsfeatures to make the projects

comparable in terms of difficulty and

size.Project complexity evaluation is an

ongoing process and the instructor

and TAs keep tabs on the projectthroughout the semester fromrequirements, prototyping, design, and

final demo with feedback being

given at each phase.


20/64

20






Data Structures


Architecture

Algorithms


Languages

Software Design 3


21/64

21

COURSE DESCRIPTION


Number


Fall 2008

Giora Slutzki

Course Title Design and Analysis of Algorithms Total Credits 3

Current Catalog Description (3-1) Cr. 3. F.S. Prereq: 228 with C- or better, 229 or Cpr E 211, Math 166, Engl

250, and either Com S 330 or Cpr E 310. Basic techniques for design and analysis of efficient algorithms.

Asymptotic ,worst-case, analyses. Graphs and graph algorithms. Design techniques such as greedy (scheduling,

Dijkstras algorithm, minimum spanning trees, Huffman codes), divide-and-conquer (mergesort, integer

multiplication), and dynamic programming (segmented least-squares, knapsack, sequence alignment, shortest paths).Network flows, Ford-Fulkerson algorithm. NP-completeness.

Programming project. Credit may not be applied toward graduation for both 311 and 381. Nonmajor graduate credit.

Textbooks (1)Algorithm Designby J. Kleinberg and E. Tardos; Addison Wesley, 2006,

ISBN 0-321-29535-8

(2)Introduction to Algorithmsby T.H. Cormen, C.E. Leiserson, and R. Rivest; McGraw-Hill, 2ndedition, 2001. ISBN 0-07-013151-1

Coordinators Giora Slutzki, Professor

David Fernandez-Baca, Professor

Course Outcomes Algorithms are the basic recipes for solving computational problems. Upon completion of this

course, students should:

understand the fundamental principles underlying algorithm analysis and design andbe able to apply them in specific instances

understand asymptotic worst-case analysis understand essential algorithm design techniques such as divide-and conquer, dynamic programming and

the greedy methods and many of its applications

understand network flow algorithms and applications understand the notion of NP-completeness.

Relationship between Course Outcomes and Program Outcomes: A, J


1. Data Structures

2. Discrete Computational Structures


1. Asymptotic analysis of algorithms2. Recurrences

3. Sorting4. Data Structures5. Advanced Algorithm Design Techniques6. Graph Algorithms7. Network Flow Algorithms9. NP-Completeness

Laboratory Projects

1. Implementation of simple kind of suffix trees and operations on them


22/64

22



Improvements

Identified

Improvements

Implemented

Understanding of

some basic

algorithmic

principles (H)

Performance on

homework andexams, senior

outcomes assessment

surveys

Every semester

Students had

difficulties in

understanding greedy

algorithms vs.,

dynamicprogramming and

strongly connected

components.

More examples were

given in lecture to

illustrate the

execution of

algorithms.

Designing computerprograms for abstract

algorithms (H)

Extra creditprogramming

project, senior

outcomes assessmentsurveys

Every semester More practicalproblems for

students to solve

using algorithmslearned in lecture.

Some improvementsimplemented but

more room for

improvement.





As indicated in the tables in Section 5-B, the credits for this course fall in the advanced category, because of the

rigor and depth of the topics covered. The text book by Cormen et al. is typically used as a graduate-level text bookin many universities.


Algorithms 3Computer Organization andArchitecture

Data structures


Languages

Software Design


23/64

23

COURSE DESCRIPTION


Number


Fall 2008

Gurpur Prabhu

Course Title Introduction to Computer Architecture and

Machine-Level Programming

Total Credits 3

Current Catalog Description(3-1) Cr. 3. F.S. Prereq: 229, Cpr E 210 and Engl 250. Introduction to

computer architecture and organization. Emphasis on evaluation of performance, instruction set architecture,

datapath and control, memory-hierarchy design, and pipelining. Assembly language on a simulator. Nonmajorgraduate credit.

Textbook D. A. Patterson and J. L. Hennessy, Computer Organization & Design: The Hardware/SoftwareInterface, Morgan Kaufmann Publishers Inc., Second edition.

Reference Interactive Computer Architecture Tutorial by Gurpur Prabhu

http://www.cs.iastate.edu/~prabhu/Tutorial/title.html

Coordinator Gurpur Prabhu, Associate Professor

Course Outcomes

Students will learn about computer performance, computer design, and tradeoffs between cost andperformance as well as between hardware and software

Students will formulate and solve problems, understand the performance requirements of systems Students will learn to communicate effectively and learn to think creatively and critically, both

independently and with others

Relationship between Course outcomes and Program outcomes:B, C, J


1. A High-level Programming Language2. Introduction to Digital Design


1.Introduction: Computer abstractions and technology2. Measuring and Evaluating Performance: Metrics of performance; Amdahls Law; Cost/benefit tradeoffs;

Instruction count, CPI, Clock cycle time; Comparing and summarizing performance

3. Instruction Set Architecture and Assembly Language of MIPS; Signed and unsigned numbers; Representing

instructions - the MIPS instruction set; Instructions for decision making; Supporting procedures - stack pointer;Arithmetic and Logical operations

4. Processor Datapath and Control; Building a datapath for R-type, I-type, and Jump instructions; A simple

implementation scheme; How control is supposed to work; A multicycle implementation5. Memory Hierarchy Design: A framework for memory hierarchies; The basics of caches; Placement,

replacement, and memory interaction policies; Measuring and improving cache performance; FIFO, LRU, write

back and write through policies

6. Enhancing Performance with Pipelining; Overview of pipelining; A pipelined datapath; Data hazardsand forwarding; Data hazards and stalls; Branch hazards

7. Exceptions and Exception Handling: Interrupts and exceptions; Hardware/software interface; Interrupt handlers


24/64

24

Laboratory Projects

5 MIPS Assembly Language Programming Exercises, Lab Exam as part of Exam 2



Improvements

Identified

Improvements

Implemented

Comprehension of

tradeoffs involved in

design choices (H)

Student performance

on quizzes and

exams which aregraded by the course

instructor and not the

TAs, senioroutcomes assessment

surveys

Every semester Students had

difficulties in

formulatingproblems in

computer

architecture and thuscould not solve them.

- More in class

examples are worked

out.- Periodic in-class

activities are

conducted wherestudents work in

groups of two or

three to formulate

and solve problemsin lecture.

Comprehension ofmemory tradeoffsand management

policies

Performance onquizzes andhomework

Every semester Students seemed tohave differentlearning strategies

for these concepts

A visual hands-onJava tutorial isavailable for students

who are visual

learners.







Algorithms


Architecture 2

Data StructuresConcepts of ProgrammingLanguages 1

Software Design


25/64

25

COURSE DESCRIPTION


Number


Fall 2008

Soma Chaudhuri

Course Title Discrete Computational Structures Total Credits 3

Current Catalog Description(3-1) Cr. 3. F.S. Prereq: 229, Math 166 and Engl 250.Concepts in discrete

mathematics as applied to computer science. Logic, proof techniques, set theory, relations, graphs, combinatorics,

discrete probability and number theory. Nonmajor graduate credit.

Textbook Discrete and Combinatorial Mathematics (Fifth ed.) by Ralph P. Grimaldi

Coordinators Giora Slutzki, ProfessorJack Lutz, Professor

Soma Chaudhuri, Associate Professor

Course OutcomesTo introduce students to the theoretical foundations of computer science which prepare them for their

study of virtually all subsequent material in the curriculum. Upon completing this course the students

should be able to:

define the fundamental discrete mathematical structures used in computer science reason about these structures and prove rigorously that their reasoning is correct apply them in problem solving and analysis, and know basic problem solving strategies and be adept at using them



1. Two semesters of Programming

2. Two semesters of Calculus


1. Sets, Functions, Asymptotics2. Number Theory3. Logic4. Proof Methods5. Combinatorics6. Discrete Probability7. Recursive Algorithms and Recurrences8. Relations9. Graph TheoryLaboratory Projects

None.


26/64

26


Outcome


Identified

Improvements

Implemented

Reason aboutstructures and prove

their correctness

Performance onhomework and

exams

Every semester Students havedifficulties in writing

proofs

Demonstrate prooftechniques through

examples and show

students how to

generalize and

produce argumentsto covert the cases in

the examples.

Be adept at using

problem-solvingstrategies

Feedback from

Recitation Section

Every semester Some students are

not able to formulatestrategies for new

problems.

Introduce students to

the technique ofreduction where

new problems arereduced to old onesand then apply

strategies used to

solve the oldproblems.






As indicated in the tables in Section 5-B, the credits for this course fall in the mathematics category. This has been

the designated category for this course since 1994.


Data Structures


Architecture

Algorithms


Languages

Software Design Mathematics 3


27/64

27

COURSE DESCRIPTION


Number

Com S 331 Course

Coordinators

Fall 2008

Giora Slutzki,

Jack Lutz,

Soma Chaudhuri

Course Title Theory of Computing Total Credits 3

Current Catalog Description(Cross listed with Ling.) (3-1) Cr. 3. F.S. Prereq: 228, 229, Com S 330 or CprE 310,

Math 166, and Engl 250. Models of computation: finite state automata, pushdown automata and Turing machines.

Study of grammars and their relation to automata. Limits of digital computation, unsolvability and Church-Turing

thesis. Chomsky hierarchy and relations between classes of languages. Nonmajor graduate credit.

TextbookAutomata and Computabilityby Dexter Kozen

ReferenceElements of the Theory of Computation, by Harry Lewis and Christos Papadimitriou (2nd edition)

Introduction to the Theory of Computation, by Michael Sipser

Introduction to Automata Theory, Languages, and Computation, by John Hopcroft, Rajeev Motwani and Jeff

Ullman.

Coordinators Giora Slutzki, Professor

Jack Lutz, ProfessorSoma Chaudhuri, Associate Professor

Course Outcomes

To introduce the computer science students to the theoretical foundations of computer science. To study abstract models of information processing machines and limits of digital computation. To provide theoretical preparation for the study of programming languages and compilers. To develop the skills of formal and abstract reasoning as needed; for example, when designing, analyzing,and/or verifying complex software/hardware systems.



1. Programming with Data Structures

2. Discrete Computational Structures


1. Introduction. Alphabets and strings, concatenation, languages, operations on strings and

languages, regular expressions and regular languages.

2. Finite-state Automata. Deterministic finite-state automata, non deterministic finite-state automata,subset construction, regular expressions, Kleenes theorem.

3. Push-down Automata. Non deterministic push-down automata, acceptance by final state andempty stack, deterministic push-down automata.

4. Turing Machines. Deterministic Turing machines, recursive and recursively enumerable

languages, non deterministic Turing machines, always-halting non deterministic Turing machines.

5. Grammars and Their Machines. Grammars: regular grammars context-free grammars, phrase-structure and contest-sensitive grammars; transitions between grammars and machines.

Derivations and derivation trees. Simplification of context-free grammars and Chomsky normal


28/64

28

form. The Chomsky hierarchy.

6. Properties of Classes languages. Boolean closure properties, regular closure properties, other

closure properties.

7. Properties of languages. Pumping properties of languages and non-membership proofs for regular

and context-free languages.8. Other topics to be decided as time permits.

Laboratory projects

None.



Improvements

Identified

Improvements

Implemented

To develop skills of

formal and abstractreasoning (A, H)

Student performance

on homework andexams

Every semester Some students have

difficulty extractinguseful methods from

proofs.

For long proofs, an

overview is given inone lecture; the

overview is repeatedbefore the proof in

the next lecture; then

the technique isapplied to an

example with explicitreference to the

proof.







rigor and depth of the topics covered.


Data Structures


Architecture

AlgorithmsConcepts of ProgrammingLanguages

Software Design Theory 3


29/64

29

COURSE DESCRIPTION


Number

Com S 342 Course

Coordinators

Hridesh Rajan

Ting Zhang

Course Title Principles of Programming Languages Total Credits 3

Current Catalog Description(3-1) Cr. 3. F.S. Prereq: 321, 330 or Cpr E 310, either 309, 362 or 363, Engl 250.

Organization of programming languages emphasizing language design concepts and semantics. Study of language

features and major programming paradigms, especially functional programming. Programming projects. Nonmajor

graduate credit.

Textbooks: Essentials of Programming Languages (3rd Edition) by Daniel P. Friedman and Mitchell Wand (MIT Press

2008) Programming Language Pragmatics (3rd Edition) by Michael L. Scott (Morgan Kaufmann, 2009).

Reference The Little Schemer (Fourth Edition) by Daniel P. Friedman and Matthias Felleisen (MIT Press, 1996).

Effective Java (2nd Edition) by Joshua Bloch (Prentice Hall, 2008).

Learning Python (3rd Edition) by Mark Lutz (O'Reilly, 2008)Coordinators

Hridesh Rajan, Assistant Professor Ting Zhang, Assistant Professor

Course Outcomes

The main objective is that students will have a deep, working knowledge of the functional paradigm and the keyideas used in modern programming languages. In more detail the essential objectives for this course are that students

will be able to: Write and modify programs using a mostly-functional style. This means programming that makes effective

use of the abstraction mechanisms of functional languages, such as higher-order functions (functions that

take functions as arguments and return functions as results) to achieve generality and abstraction.

Write and modify programs that make effective use of data abstraction. Modify interpreters to change or enhance their behavior so as to implement various features of

programming languages such as: control flow, variables, recursion, scoping, syntactic sugars, arrays,

parameter passing mechanisms, type checking, objects, classes, and inheritance.

Write programs using such features, and explain, using appropriate terminology, the user-visible behaviorof such programs.

Explain, using appropriate terminology, the data structures and algorithms used in interpreters to implementsuch features. Compare alternatives in the design and implementation of such features.

Relationship between Course Outcomes Program Outcomes: C, H, I, J, K

Prerequisite(s) by Topic

1. Computer architecture and machine-level programming2. Theory of computing

3. File organization and processing


30/64

30


1. Formal language theory: regular languages, context-free languages, finite state automata2. Write and modify programs in functional style, introduction to languages such as Scheme and Haskell and

language implementation techniques such as lazy data structures and monads

3. Make effective use of data abstraction4. Learn about language constructs by changing or enhance interpreters to have features such as: control flow,

variables names and bindings, recursion, static and dynamic scoping, syntactic sugars, arrays, parameter

passing mechanisms, continuations, co-routines, type checking, objects, and inheritance

5. Write programs using such features and explain their behavior6. Explain the data structures and algorithms used in interpreters7. Logical programming: Prolog, resolution principles, unification algorithm, search with backtracking, cut

operation, negation as failure

8. Compare alternatives in programming language design and implementationsLaboratory projects

1. Using Scheme, Python, Prolog, Haskell2. Language Design and Recursion: LL(1) parsing

3. Formulating Abstractions with Higher-order Procedures: Curry and Uncurry functions

4. Data Abstraction and Object-oriented techniques

5. Conventional interfaces and symbolic data: list manipulations

6. Java visitors and iterators, multiple representations, and systems with generic operations


Outcome How Measured When Measured Improvements

Identified

Improvements

Implemented

An ability to design,implement, and

evaluate a computer-

based system,

process, componentor program to meet

desired needs.

Student performanceon homework,

projects, and exams

Feedback fromcompanies

Every semester

Students had animperative method of

approaching a

problem.

Carefully stressed theimportance of other

computing paradigms

such as logic and

functional paradigms

An ability to engagein continuing

professional

development.

Student performanceon homework and

exams

Feedback fromcompanies

Every semester Students didnt havea basic framework

for learning new

computer languages.

Taught a module thatlays the framework

An ability to usecurrent techniques,

skills, and tools

necessary forcomputing practices.

Student performancein homework and

exams

Student feedback

during graduating

Every semester Students didnt havemuch chance to

apply their

knowledge about PLtheory to new

mainstream language

Included an exerciseto study current

languages such as

Python, C#, and Java1.7


31/64

31

senior assessment proposals.

An ability to apply

mathematical

foundations,

algorithmicprinciples, and

computer sciencetheory in the

modeling and designof computer-based

systems that

demonstratecomprehension of

the tradeoffs

involved in design

choices.

Student performance

in homework and

exams.

Every semester Formal language

theory and recursive

(top-down/bottom-

up) construction offunctions.

Included a module on

LL(1) parsing to

address this issue and

basic previewmodule on regular

languages.

An ability to apply

design and

development

principles in theconstruction of

software systems ofvarying complexity.

Student performance

on programming

homework, and

projects.

Every semester Students didnt know

about functional and

logic programming-

based design styles.

Taught the follow

the grammar

principle which helps

with writingfunctional programs.









Data StructuresComputer Organization andArchitecture

Algorithms


Languages 2

Software Design 1


32/64

32

COURSE DESCRIPTION


Number


Fall 2008

Lu Ruan

Dimitris Margaritis

Course Title Introduction to Operating Systems Total Credits 3

Current Catalog Description(3-1) Cr. 3. F.S. Prereq: 321, and 362 or 363, Engl 250. Survey of operating system

issues. Introduction to hardware and software components including: processors, peripherals, interrupts,

management of processes, threads and memory, deadlocks, file systems, protection, virtual machines and system

organization, and introduction to distributed operating systems. Programming projects. Nonmajor graduate credit.

Textbook Operating Systems Concepts: 6th Edition (2003)by Silberschatz, Galvin, and Gagne,

John Wiley & Sons

References1. Modern Operating Systems: 2nd Edition by Andrew Tanenbaum, Prentice Hall, 2001.2. Unix Network Programming: 2nd Edition by W. Richard Stevens, Prentice Hall, 1998.

Coordinators Dimitris Margaritis, Assistant Professor

Lu Ruan, Assistant Professor

Course Outcomes

Students will learn about and understand theoretical concepts and programming constructs used for theoperation of modern operating systems

Students will gain practical experience with software tools available in modern operating systems such assemaphores, system calls, sockets and threads.

Relationship between Course Outcomes and Program Outcomes: C, D, H, K


1. Computer Architecture2. Programming in C++Major Topics covered in the Course

1. System Structures Overview

2. Processes, threads, and CPU scheduling

3. Process synchronization and deadlocks4. Memory Management and Virtual Memory5. Distributed Systems Structures6. File SystemsLaboratory projects

1. Creating concurrent processes using the fork system call and interprocess communication using pipes2. Process synchronization using semaphores3. Client/Server communication using sockets


33/64

33


Outcome How Measured When MeasuredImprovements

IdentifiedImprovements

Implemented

Students had problems

understanding the

concepts of semaphoresand monitors.

Monitoring student

grades in homeworkassigned on the topic.

Every semesterStudents needed more

instruction on the topic.Instructor presented

and discussed solutions

to similar exercises inclass in detail.

Students applying

textbook

synchronizationsolution to

programming problem

involving slightly

different

synchronizationproblem.

Conversations with

students before projectwas due, in class.

Every semester Theoretical concepts

were not understood in

depth.

Additional time in class

was spent on the topics

and more exampleswere presented.








Data Structures Computer Organization andArchitecture

1

Algorithms 1 Concepts of ProgrammingLanguages

Software Design 1


34/64

34

COURSE DESCRIPTION


Number


Fall 2008

Les Miller

Course Title Object-Oriented Analysis and Design Total Credits 3

Current Catalog Description(3-0) Cr. 3. F.S. Prereq: 228 with C- or better, Engl 250. Object-oriented

requirements analysis and systems design. Design notations such as the Unified Modeling Language. Design

Patterns. Group design and programming with large programming projects. Nonmajor graduate credit.

TextbookStructure and Interpretation of Computer Programs, Second Editionby Harold Abelsonand Gerald JaySussmanwith Julie Sussman(MIT Press and McGraw-Hill, 1996).

ReferenceThe Little Schemer (Fourth Edition)by Daniel P. Friedmanand Matthias Felleisen(MIT Press, 1996).

The Java Programming Language (second edition)by Ken Arnold and James Gosling (Addison-Wesley, 1998).

Coordinators Leslie Miller, Professor

Course Outcomes

The main objective is that students will be able to analyze system requirements, and create andjustify object-oriented designs that meet their requirements and that are robust and evolvable. In

more detail, the essential outcomes for this course are that students will be able to:

Analyze system requirements and model problem domains. Evaluate the quality of an analysis, and be able to explain how to improve it. Design and build object-oriented systems. Explain and justify designs based on design principles, patterns, and heuristics. Evaluate the quality of a design, and be able to explain how to improve it. Write object-oriented code to correctly implement a design. Be able to read and write analysis and design documentation in the Unified Modeling Language

(UML).

Be able to read and write object-oriented code, in Java, that uses subclasses, inheritance, abstractmethods, subtypes, and subtype polymorphism.

Relationship between Course Outcomes and Program Outcomes: C, D, H, I, K


1. Computer architecture and machine-level programming

2. Theory of computing

3. File organization and processing


1. Introduction2. Procedural Abstraction3. Data Abstraction4. Modularity, Objects, State5. Metalinguistic Abstraction6. Course Summary and Evaluation


35/64

35

Laboratory projects

1. Using Scheme

2. Language Design and Recursion

3. Formulating Abstractions with Higher-order Procedures4. Data Abstraction

5. Object-oriented techniques

6. Conventional interfaces and symbolic data7. Java visitors and iterators, multiple representations, and systems with generic operations



Improvements

Identified

Improvements

Implemented

Evaluate the quality

of a design, and be

able to explain howto improve it.

Student performance

on homework, team

projects, and exams

Feedback fromcompanies and other

courses

Every semester

Too much stress on

completing the

projects.

Moved core design

material to the

beginning of thesemester.

Analyze system

requirements and

model problem

domains.

Student feedback Every semester Confusion between

system sequence

diagrams and

interaction diagrams.

Material on system

sequence diagrams

moved to later in the

semester to allowstudents to more

clearly understand

the role of interaction

diagrams.






Data Structures


Architecture

Algorithms


Languages 2

Software Design 1


36/64

36

COURSE DESCRIPTION


Number


Fall 2008

Shashi Gadia

Course Title Introduction to Database Management

Systems

Total Credits 3

Current Catalog Description(3-0) Cr. 3. F.S. Prereq: 228 with C- or better, Engl 250. Relational, object-oriented,

and semistructured data models and query languages. SQL, ODMG, and XML standards. Database design using

entity-relationship model, data dependencies and object definition language. Application development in SQL-likelanguages and general purpose host languages with application warehouses, mediators and wrappers. Programming

Projects. Non-major graduate credit.

Textbook Shashi K. Gadia.An Elemental Introduction to Databases. A set of class notes.

Coordinator Shashi K. Gadia, Associate Professor

Course Outcomes Students will learn about largeness of data and why it gives rise to stream-oriented processing and algebraic

languages that are higher level than general-purpose programming language such as Java.

Students will learn about storage and efficient retrieval of large information via algebraic queryoptimization and the use of indexing.

Students will learn about multiple paradigms in databases: relational, object-oriented, and semistructuredand appreciate why XML is a powerful emerging model for databases and its broader impact.

Students will learn how data from multiple heterogeneous sources is integrated.Relationship between Course outcomes and Program outcomes:H, I, J, K


1. A High-level Programming Language2. Introduction to Digital Design


1. Introduction:Largeness of information and its implications on organization of disk in terms of blocks in kilobyte range

rather than words consisting of a few bytes. Layered architecture of databases and varieties of users.2. Query languages in different paradigms and hybrid languages

Foundational language relational algebra and how it gives rise to user-oriented language SQL. How SQL is

reincarnated as OQL and XQuery in object-oriented and XML data models. Hybrid language JDBC (JavaDatabase Connectivity).

3. Storage and efficient retrieval of data

Storing information in blocks on a disk. Indexing. Algebraic optimization. Query processing.4. Schema design -Schema design using Entity-relationship model and data

5. Relational, object-oriented, and semistructured (XML) data models

Programming projects.

6. Information integration: Data warehousing

Laboratory Projects

Projects on SQL, JDBC, Object-oriented query, and XQuery.


37/64

37



Improvements

Identified

Improvements

Implemented

Understanding oflargeness in

information

Class discussions Every semester Give more details - Through slowerpaced class

discussion.

Broad impact of

XML

Class discussions Every semester Give more details - A lecture is

exclusively devoted

to XML to put it in

broad perspective- Efficiency issues

surrounding XML

are discussed.






Algorithms 0.50


Architecture 0.25

Data Structures 0.25


Languages 1.50

Software Design 0.50


38/64

38

COURSE DESCRIPTION


Number


Fall 2008

Carl Chang

Course Title Software Requirements Engineering Total Credits 3

Current Catalog Description(Dual-listed with 509). (Cross-listed with S E). (3-0) Cr. 3. F. Prereq: Com S 309,

Engl 250, Sp Cm 212.The requirements engineering process, including identification of stakeholders, requirements

elicitation techniques such as interviews and prototyping, analysis fundamentals, requirements specification, and

validation. Use of Models: State-oriented, Function-oriented, and Object-oriented. Documentation for Software

Requirements. Informal, semi-formal, and formal representations. Structural, informational, and behavioralrequirements. Use of requirements repositories to manage and track requirements through the life cycle. Case

studies, software projects, written reports, and oral presentations will be required. Nonmajor graduate credit.

Textbook Mastering the Requirements Process (Suzanne & James Robertson, ISBN: 0-201-36046-2)

References

Managing Software Requirements A unified Approach (Dean Leffingwell and Don Widrig, ISBN: 0-201-61593-2)

UML Toolkit by Hans-erik Eriksson and Magnus Penker. Writing effective use-cases, Alistair Cockburn, ISBN: 0-201-70225-8

Coordinator Carl Chang, Professor

Simanta Mitra, Senior Lecturer

Course Outcomes

1. Students will learn about the Requirements Engineering process.

2. Students will practice requirements analysis, modeling, elicitation, and specification on medium sized projects.3. Students will learn to work with a team on requirements elicitation on medium sized projects and practice soft

skills such as communication, presentation, and asking questions etc.

4. Students will become familiar with requirements management tools (such as Rational RequisitePro).

5. Students will be exposed to latest research in requirements engineering area.

Relationship between Course Outcomes and Program Outcomes: B, D, F, H, I, K

Prerequisite by Topics

1. Software Lifecycle2. Development of Medium sized software projects

3. Proficiency in English


1. Requirements Analysis

2. Requirements Elicitation

3. Requirements Specifications

4. Requirements Validation and Verification5. Requirements Management and Tools

6. Modeling and Modeling tools.


39/64

39


Outcome

How Measured When Measured Improvements Identified Improvements

Implemented

Learn about andpractice

requirements

processes (Course

Outcomes 1 and

2)

Studentperformance on

screenshots, actors

and use-cases,

static and dynamic

models of problemdomain

Several timesduring the

semester.

Hard to impress on students thedifference in good requirements

analysis and poor requirements

analysis.

Multiple teamsperformed analysis

for the SAME

project. Later,

findings of

different teams arecompared to drive

home the point.

Team work

(Course outcome

3)Team performancein

- reqs project

- research project

- textbook chapterpresentations

Several times

during semester.

Class has students of vastly

different backgrounds with

different levels of readiness to

absorb information and learn.

Different levels of

complexity for

team projects.

Novice studentsassigned project

where TA andinstructor arecustomers.

Intermediate

students assignedproject where

department staff

and faculty are

customers.

Advanced studentsassigned project

where external

industry

representatives arecustomers.

Students tend to form teams

with their friends or with similarnationality/ethnicity/background

thus diminishing lessons that

can be learnt from team projectsand increasing the differences

with workplace teams.

Teams are imposed

by the instructorwith an eye

towards making the

teams diverse aspossible. Forces

students out of

their comfortzones.

Learn soft and

hard skills as

needed forprofessional

development andUse current

techniques, skills

and tools (Course

outcomes 3 and 4)

Class

Presentations,Project artifacts,

Homeworks,

Final interviews

Semester

Harder to teach soft skills. Class organized

around gathering

experiences asopposed to lecture.

Students learn softskills by

participation and

engaging soft

skills.

Text book is not really designed

as an undergraduate text book.

Students work in

teams to read and


40/64

40

Outcome

How Measured When Measured Improvements Identified Improvements

Implemented

Could not find any suitable.Zero to no examples or

questions at the end of chapters.

Also text book very easy toread and lessons to be learnt

from chapters can be missed.

present eachchapter to the class.

Discussion and

question/answersession at the end

of chapter. This

approach allows

more engagement

with material thanby pure lecture.






Data Structures


Architecture

Algorithms


Languages

Software Design 3


41/64

41

COURSE DESCRIPTION


Number


Spring 2008

Simanta Mitra

Course Title Software Testing Total Credits 3

Current Catalog Description(Cross-listed with S E). (3-0) Cr. 3. S. Prereq: Com S 309, 319, Engl 250, Sp Cm

212. Comprehensive study of software testing, principles, methodologies, management strategies and techniques.

Test models, test design techniques (black box and white-box testing techniques), integration, regression, system

testing methods, and software testing tools. Nonmajor graduate credit. Oral and written reports.

TextbookAditya Mathur, Foundations of Software Testing, Addison-Wesley Professional, April 17, 2008.

References

1. Cem Kaner, Hung Nguyen, jack Falk, "Testing Computer Software", 2nd Edition, John Wiley & Sons, April 1999.(ISBN: 0471358460).

2. Boris Beizer, "Black-Box Testing: Techniques for Functional Testing of Software and Systems", John Wiley &Sons,1995. (ISBN: 0471120944)

3. Boris Beizer, "Software Testing Techniques", second edition, Vannostrand Reinhold, 1990.4. Mark Fewster and Dorothy Graham, "Software Test Automation - Effective Use of Test Execution Tools", ACM

Press and Addison-Wesley, 1999 (ISBN: 0-201-33140-3).

5. Elfriede Dustin, Jeff Rashka and John Paul, "Automated Software Testing: Introduction, Management, andPerformance", Addison-Wesley Pub Co, 1999. (ISBN: 0201432870)

Coordinator Simanta Mitra, Senior Lecturer

Course Outcomes

At the end of the course, a student who passes is expected to have met the following learning objectives.1. is knowledgeable about the basic vocabulary and concepts of this area, knows about the different test

generation and selection techniques and is able to apply this knowledge.

2.

understands the idea of software testability and designing for testability.3. understands how inspections/reviews are conducted and why they are so important at all stages of thedevelopment process. Knows about the V-model.

4. has created and executed tests using testing tools (like JUnit/TestManager). Understands the need forautomation and has used automation tools.

5. has designed and conducted testing on a software project starting from test plan to test report.6. Recorded and managed information about defects found using a defect tracking tool. Debugged and fixed

using IDE and managed different versions of software using source control tool.

7. Knows how to evaluate test cases and has evaluated test cases for the project using coverage tools.8. is able to evaluate the software based on the tests.9. knows about the issues and is able to apply knowledge of how to generate test cases for some domain-

specific testing such as: GUI, OO, Web, Component Testing etc.10. knows about the journals and conferences related to testing and has explored a topic and made a

presentation to the class on this topic and written a report on this - has been exposed to contemporary work

by researchers.

Relationship between Course Outcomes and Program Outcomes: C, D, F, H, I, K

Prerequisite by Topics

1. Software Lifecycle

2. Development of Medium sized software projects3. Proficiency in English



42/64

42

1. Introduction to software testing2. Black-box testing3. White-box testing4. Integration testing5. Coverage and Regression testing6. System testing and performance measurement7. Software test automation and tools8. Software quality assurance9. Domain specific issues

a. Interproceduralb. Concurrencyc. Object orientedd. Performancee. Web Basedf. GUI testing


Outcome


Identified

Improvements

Implemented

Students understand

how to log bugs and

then fix defects on abranch and have

defects follow

controlled bugs life

cycle.(CourseOutcome#7)

Subversion logs,

bugzilla logs.

At the end of the

testing project.

Earlier students had

not been creating

branches to fix bugsand instead were

working on the

trunk. The problem

was figuring out howto create branches

and tags.

Branching and

Tagging were

explained morerigorously and the

testing project

instructions were

made more explicit.

Students needexposure to

contemporary work

by researchers(Course

outcome#12)

Guest presenters,Research project

outcomes.

At the end of thesemester.

Need guest lecturers. Asked departmentexperts on testing to

present. Dr. Samik

Basu presented hiswork to the class.

How Data in the Course is used to assess

courses+outcomes+assessments 1

Documents