I was just working through the new ACM Curricular guidelines trying to get a list of those learning outcomes met by this course. I think I probably won't do the course complete justice till after I've taught it, but if anyone has more experience with the course and is familiar with the new guidelines:
http://www.acm.org/education/CS2013-final-report.pdfI'd love to get your input. Here's my first draft:
AR. Architecture and Organization [core]
AR/Digital Logic and Digital Systems
* Articulate that there are many equivalent representations of computer functionality, including logical expressions and gates, and be able to use mathematical expressions to describe the functions of simple combinational and sequential circuits. [Familiarity]
* Design the basic building blocks of a computer: arithmetic-logic unit (gate-level), registers (gate-level), central processing unit (register transfer-level), memory (register transfer-level). [Usage]
* Use CAD tools for capture, synthesis, and simulation to evaluate simple building blocks (e.g., arithmetic- logic unit, registers, movement between registers) of a simple computer design. [Usage]
AR/Machine Level Representation of Data
* Explain why everything is data, including instructions, in computers. [Familiarity]
* Explain the reasons for using alternative formats to represent numerical data. [Familiarity]
* Describe how negative integers are stored in sign-magnitude and twos-complement representations.
[Familiarity]
* Explain how fixed-length number representations affect accuracy and precision. [Familiarity]
* Describe the internal representation of non-numeric data, such as characters, strings, records, and arrays.
[Familiarity]
* Convert numerical data from one format to another. [Usage]
* Write simple programs at the assembly/machine level for string processing and manipulation. [Usage]
AR/Assembly Level Machine Organization
* Explain the organization of the classical von Neumann machine and its major functional units. [Familiarity]
* Describe how an instruction is executed in a classical von Neumann machine, with extensions for threads,
multiprocessor synchronization, and SIMD execution. [Familiarity] - 64 -
* Describe instruction level parallelism and hazards, and how they are managed in typical processor pipelines. [Familiarity]
* Summarize how instructions are represented at both the machine level and in the context of a symbolic assembler. [Familiarity]
* Demonstrate how to map between high-level language patterns into assembly/machine language notations. [Familiarity]
* Explain different instruction formats, such as addresses per instruction and variable length vs. fixed length formats. [Familiarity]
* Explain how subroutine calls are handled at the assembly level. [Familiarity]
* Explain the basic concepts of interrupts and I/O operations. [Familiarity]
* Write simple assembly language program segments. [Usage]
* Show how fundamental high-level programming constructs are implemented at the machine-language
level. [Usage]
AR/Memory System Organization and Architecture
* Describe the principles of memory management. [Familiarity]
* Explain the workings of a system with virtual memory management. [Familiarity]
AR/Functional Organization
* Compare alternative implementation of datapaths. [Familiarity]
* Discuss the concept of control points and the generation of control signals using hardwired or
microprogrammed implementations. [Familiarity]
* Explain basic instruction level parallelism using pipelining and the major hazards that may occur.
[Familiarity]
* Design and implement a complete processor, including datapath and control. [Usage]
* Determine, for a given processor and memory system implementation, the average cycles per instruction.
[Assessment]
OS. Operating Systems [core]
OS/Overview of Operating Systems
* Explain the objectives and functions of modern operating systems. [Familiarity]
* Analyze the tradeoffs inherent in operating system design. [Usage]
* Describe the functions of a contemporary operating system with respect to convenience, efficiency, and the
ability to evolve. [Familiarity]
OS/Operating System Principles
* Explain the concept of a logical layer. [Familiarity]
* Explain the benefits of building abstract layers in hierarchical fashion. [Familiarity]
* Describe the value of APIs and middleware. [Assessment]
* Describe how computing resources are used by application software and managed by system software.
[Familiarity]
OS/Memory Management
* Explain memory hierarchy and cost-performance trade-offs. [Familiarity]
* Summarize the principles of virtual memory as applied to caching and paging. [Familiarity]
* Evaluate the trade-offs in terms of memory size (main memory, cache memory, auxiliary memory) and
processor speed. [Assessment]
OS/Virtual Machines
* Explain the concept of virtual memory and how it is realized in hardware and software. [Familiarity]
* Differentiate emulation and isolation. [Familiarity]
* Evaluate virtualization trade-offs. [Assessment]
OS/File Systems
* Describe the choices to be made in designing file systems. [Familiarity]
* Compare and contrast different approaches to file organization, recognizing the strengths and weaknesses
of each. [Usage]
* Summarize how hardware developments have led to changes in the priorities for the design and the
management of file systems. [Familiarity]
PL. Programming Languages [core]
PL/Language Translation and Execution
* Distinguish a language definition (what constructs mean) from a particular language implementation (compiler vs. interpreter, run-time representation of data objects, etc.). [Familiarity]
* Distinguish syntax and parsing from semantics and evaluation. [Familiarity]
* Sketch a low-level run-time representation of core language constructs, such as objects or closures.
[Familiarity]
* Explain how programming language implementations typically organize memory into global data, text,
heap, and stack sections and how features such as recursion and memory management map to this memory
model. [Familiarity]
PL/Syntax Analysis
* Use formal grammars to specify the syntax of languages. [Usage]
* Use declarative tools to generate parsers and scanners. [Usage]
* Identify key issues in syntax definitions: ambiguity, associativity, precedence. [Familiarity]
PL/Compiler Semantic Analysis
* Identify all essential steps for automatically converting source code into assembly or other low-level languages. [Familiarity]
* Generate the low-level code for calling functions/methods in modern languages. [Usage]
PL/Runtime Systems
* Compare the benefits of different memory-management schemes, using concepts such as fragmentation, locality, and memory overhead. [Familiarity]
* Discuss benefits and limitations of automatic memory management. [Familiarity]
* Explain the use of metadata in run-time representations of objects and activation records, such as class
pointers, array lengths, return addresses, and frame pointers. [Familiarity]
Best regards
Sam Joseph, Ph.D.
Associate Professor,
Department of Computer Science
Hawaii Pacific University
Sam Joseph, Ph.D.
Associate Professor
Department of Computer Science
Hawaii Pacific University
Locked
