Computing Migration Strategies

Prabhu

Description

• cours - matière potentielle : action
• exposé - matière potentielle : application
• exposé - matière potentielle : layer

Computing Migration Strategies White paper: Computing Migrations Jim Piazza Sr. Director, Solutions Consulting - East, Savvis table of Contents 2 Executive Summary 2 Introduction 3 Seven Deadly Layers 4 Smart Objects 5 Other Considerations 5 Migration Types 9 STM: Savvis Transformation Methodology 10 Post-Migration: The Aftermath 11 Summary 12 How Savvis Can Help

• end of the migration
• savvis transformation methodology
• migrations
• savvis
• application layer
• host operating system
• migration
• layer
• systems
• hardware

Sujets

• Action
• Application
• Piazza
• Deadly
• Microsoft
• Migration
• System
• Hardware
• Savvis

Informations

• Publié par: miphug
• Nombre de lectures: 24
• Langue: English

Extrait

Computer Science Course Descriptions
including
Course Outcomes
Assessment Plans
Course Improvements
1

COURSE DESCRIPTION

Department and Course Com S 227 Coordinators James Lathrop, Steve
Number Fall 2008 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 Outcomes
At 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 Topic
High 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
2
• 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 IDE
2. Java API documentation; the Javadoc tool; creating a simple class
3. String manipulation; evaluating expressions
4. Interacting classes; Boolean expressions
5. Command-line tools and shell commands
6. Code style and formatting
7. The Eclipse debugger
8. Exception handling; File I/O
9. JUnit
10. Inheritance and polymorphism; creating Exception types
11. Recursion


Assessment Plan for the Course

Improvements Improvements
Outcome How Measured When Measured Identified Implemented
Write, debug, Evaluation of Every semester Students tend to Implement a series of
and document programming projects postpone reviewing structured hands-on
well-structured and learning new laboratory exercises for
Java material until just new and/or difficult
applications of prior to project topics to ensure
up to 500 lines deadlines. students absorb them
(B, C) well before needed for
projects.

Implement Java Exams; evaluation of Every semester Students fail to Make sure that one or
classes from programming projects grasp the role of more of the
specifications specifications in programming projects
(C) implementing involves integration of
components of a student-implemented
system. classes with existing
libraries.
Use interfaces, Performance of Every semester Students fail to Include laboratory
inheritance, and continuing students at comprehend the exercises using
polymorphism start of Com S 228; use of interfaces in interfaces and
as programming exams; evaluation of a design. inheritance. Ensure
techniques (B) programming projects that one or more of the
programming projects
requires students to
program with
interfaces.

3

How Data in the Course is used to assess Program Outcomes

Assessment data from each course is given to the department’s undergraduate committee. A detailed description of
how this data is used to assess program outcomes is provided in Appendix A, the department’s Learning Outcomes
and Assessment Plan.

Curriculum Category Content (Semester Hours)

CORE ADVANCED CORE ADVANCED
Computer Organization and
Algorithms Architecture
Concepts of Programming
Data Structures Languages 2
Software Design 2

4
COURSE DESCRIPTION

Department and Course Com S 228 Course Coordinator James Lathrop
Number Fall 2008

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, with
emphasis 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, writing
and documenting medium-sized programs. This course is designed for majors.

Textbook William J Collins, Data Structures and the Java Collections Framework, Second Edition, McGraw Hill
2005. 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.

5
Major Topics Covered in the Course

Topic Reading from text
CS 227 review Ch 1, 2
Runtime Analysis Ch 3
Sorting Algorithms Ch 5, 11
Collection Interface and Iterators Ch 4
Lists and the ArrayList class Ch 6
Lists and linked lists Ch 7
Stacks and Queues Ch 8
Trees Ch 9
Binary Search Trees Ch 10
Tree 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, and
progra