Difference between revisions of "Data Structures and Algorithms for Engineers"

Revision as of 03:51, 23 December 2016

|CARNEGIE MELLON UNIVERSITY IN RWANDA|

04-801/F3
Data Structures and Algorithms for Engineers

Course discipline: TBD

Core

Units: 12

Lecture/Lab/Rep hours/week: 4 hours lectures/week, 1.5 hours labs/week (two sessions), 1 hour recitation/week (two sessions)

Semester: Spring

Pre-requisites: programming skills Students are expected to be familiar with programming in at least one programming language. Formal programming language training is not required. Students may not have any formal background in algorithms, data structures, analysis, or detailed design techniques and methods.

Course description:

Many organizations today are incorporating computer hardware and software into the products that they design and build. Most of these organizations' primary competencies are not computer science or software engineering, but rather they find that automation makes their products smarter, more capable, and more appealing in the market place. Because deep domain knowledge is needed to build these products, these organizations often hire engineers from traditional engineering disciplines to design and build the product platform, in many cases requiring them to write software to make the product actually work. These are capable engineers from many disciplines other than software engineering and unfortunately they usually learn software engineering on the job. This process typically involves considerable trial and error and often results in poorly designed and documented systems, defect laden software, bloated product development costs, unmaintainable software, and missed opportunities to leverage software development investments.

In addition to developing mere functionality, some application domains are often highly constrained and unforgiving in their quality attribute needs such as performance, safety, and availability. These systems intimately depend upon software to provide these capabilities in addition to basic functionality. Designing software intensive systems with these properties in a cost-effective way requires first-class computer science and software engineering expertise. While many practicing engineers often have many years of industrial experience writing software applications, many lack a formal background in computer science principles. These engineers may have had a few courses or technical training in specific computer languages or technologies, but in general they often lack formal training in algorithms, computing theory, data structures, and design among other key topics. The result is that many of these engineers are not fully realizing their potential as software engineers. This course is designed to bridge these gaps in formal computer science training.

Learning objectives:

The primary objective of the course is to provide engineers without formal training in computer science, a solid background in the key principles of computer science. The key purpose of this course is to complement the experience that engineers may already have in writing software with formal computer science underpinnings, making those engineers more capable in developing software intensive systems. Specific learning objectives include:

• Preparing students for immediate competency so that course material can be directly applied in real world situations.
• Improving the student's ability to recognize and analyze critical computational problems in the course of their work, generate alternative solutions to problems, and judge among them.
• Enabling students to better understand, analyze, and characterize those factors that influence algorithmic computational performance and memory consumption.
• Increasing student's awareness and understanding of detailed code structures and their underlying strengths and weaknesses.
• Improve the student's ability to performed detailed, code-level design and document the design in an understandable way.

In particular, this course provides an intensive treatment of most of the key elements of algorithms and data-structures, beginning with the fundamentals of searching, sorting, lists, stacks, and queues, but quickly building to cover more advanced topics, including trees, graphs, and algorithmic strategies. It also covers the analysis of the performance and tractability of algorithms and will build on the concept of Abstract Data Types. A key focus of the course is on effective implementation and good design principles. As such, it also covers the main aspects of the software development lifecycle and various principles approaches to software design.

Outcomes:

After completing this course, students should be able to:

Content details:

(For a summary of how the course will be delivered, see the Lecture Plan.)

The course will cover the following topics:

Note: topics suggested for deprecation are listed in italics; new topics are listed in bold.

• Introduction & motivation
• Fundamental Algorithmic Strategies
• Algorithmic Representation & Analysis
• Correctness Analysis
• Measurement
• ADT Introduction and Design
• Lists
• Stacks
• Queues
• Sorting
• Trees
• Heaps
• Graphs
• Hashing
• Software Design
• Operating Systems
• Secondary Storage and File Management

The detailed content for each of these topics follows.

Introduction and motivation

• History of computer science
• Goals of the course
• Topic areas
• Course logistics

Algorithmic strategies

• Definition of an algorithm
• Algorithmic analysis and complexity
• Classes of algorithms
• Brute force, divide and conquer, branch and bound, dynamic programming, greedy algorithms, recursion, approximation, heuristics and heuristic algorithms, probabilistic algorithms

Algorithmic representation and analysis

• Modelling software
• Representation, communication, and analysis of algorithms
• Relational modelling
• State modelling
• Pseudo code
• Flow charts
• Finite state machines
• UML
• Predicate logic
• Analysis

Correctness

• Types of software defects
• Code module design
• Syntactic, semantic, logical defects
• (Semi-)formal verification: partial vs. total correctness
• Invariant assertion method
• Simple proof strategies: by contradiction, counterexample, induction
• Dynamic testing: unit tests, test harness, stubs, drivers, integration testing, regression testing.
• Static tests: reviews, walkthroughs, inspections, reviewing algorithms and software
• Pair programming
• Verification and validation strategies
• Sofware quality assurance metrics

Faculty:

David Vernon

Delivery:

Face-to-face.

Students assessment:

This course includes several hands-on programming and analysis assignments. Students will program mainly in C/C++. The programming assignments include individual assignments and a team capstone project in teams of 2-3 people. In addition to programming assignments, students will be assigned readings to support the lecture material.

Marks will be awarded as follows.

Individual Assignments 50% Final Capstone Project 40% (The capstone project will be completed in 2-3 person teams). Instructor Judgement 10% (We will use time tracking and observation to determine this part of the grade).

Software requirements:

We will use Microsoft Visual C++ Express compiler, version 10.0 (also known as Visual C++ 2010) and CMake running on Windows 7 64 bit.

A complete software installation guide will be provided in due course.

Course texts:

Algorithmics: The Spirit of Computing, Third Edition, David Harel and Yishai Feldman.

Data Structures and Algorithms, Alfred V. Aho, Jeffrey D. Ullman, and John E. Hopcroft.

A selection of papers and readings will be provided to complement these required textbooks.

Acknowledgments:

The syllabus for this course is based primarily on the following course.

• 04-630 Computer Science Principles for Practicing Engineers given by Mel Rosso-Llopart and Anthony J. Lattanze at Carnegie Mellon University.

Additional topics and teaching material have been taken from the following course.

• CS-CO-412 Algorithms and Data Structures given by David Vernon at the Innopolis University.