ECE 190
Intro to Computing Systems

Displaying course information from Fall 2013.

Section Type Times Days Location Instructor
AD1 DIS 1500 - 1550 F   L440 Digital Computer Lab  Michael Rogers
AD5 DIS 1200 - 1250 F   L440 Digital Computer Lab  Bradley Thompson
AD6 DIS 1200 - 1250 F   L520 Digital Computer Lab  Michael Rogers
AD7 DIS 1400 - 1450 F   L440 Digital Computer Lab  Michael Rogers
AD9 DIS 1100 - 1150 F   L520 Digital Computer Lab  Michael Rogers
AE1 LCD 1100 - 1220 T R   151 Everitt Lab  Yih-Chun Hu

Web Page http://courses.engr.illinois.edu/ece190/
Official Description Bits; binary representations; digital logic structures; the von Neumann computing model; an example instruction set; machine and assembly language programming; machine-level input/output; subroutines; the C programming language; variables and operators; control constructs; functions in C; pointers and arrays; input/output in C; recursion; simple data structures. Course Information: Prerequisite: ECE 110. Class Schedule Information: Students must register for one discussion and one lecture-discussion section.
Subject Area Core Curriculum
Course Prerequisites Credit in ECE 110
Course Directors Sanjay Jeram Patel
Detailed Description and Outline

This course introduces students to the programming of computing systems. The main objective of this course is to give students an exposure to basic concepts in programming using a high-level language, which in the case of this course is the C programming language. The philosophy of this course is very different than the typical introduction to programming course, however. We approach programming from the bottom upwards: we describe the low-level organization of a computer before describing how to program it. Our belief is that a bottom-up understanding of computing systems is a more solid basis for understanding advanced concepts in computing that follow in the ECE curriculum.

Topics include: logic gates, datapaths, registers, memories, machine and assembly language programming, basic programming concepts in C, functions, arrays, pointers, I/O, recursion, simple data structures, and concepts in object-oriented programming.

Computer Usage

Programming assignments are done on linux and windows computers. Web-based interface for assembly programming.

Texts

Yale N. Patt and Sanjay J. Patel, Introduction to Computing Systems: from bits and gates to C and beyond, 2nd Edition, McGraw-Hill, 2003.

ABET Category

Engineering Science: 75%
Math/Basic Science: 25%

Course Goals

The main objective of this course is to give student exposure to basic concepts in programming. The philosophy of this course is very different than the typical introduction to programming course. We approach programming from the bottom upwards: we describe the architecture of a computer before describing how to program it. The course works upwards starting from the basic abstractions such as binary representations; devices, logic gates; muxes, decoders, registers, memories; finite state machines and computer organization; machine and instruction set architecture(ISA); leading up to the C programming language. Each new C concept is related to the fundamental concepts described in the first portion of the course. We cover basic programming concepts, functions, arrays, pointers, I/O, recursion, simple data structures, and concepts in object-oriented programming.

Student evaluation consists of four homework assignments and a midterm exam in the first segment of the course, five programming assignments and a midterm exam in the second segment of the course(four of the programming assignments are broken into two separate checkpoints to ensure that students are making progress), and a final examination.

Instructional Objectives

Binary Representations: Understand binary representations in modern digital systems, such as 2’s complement, unsigned, IEEE floating-point, and ASCII. Be able to develop representations for arbitrary sets using both bit patterns and data structures. (a, m, n)

Digital Logic: Understand the notion of logical correctness, be able to implement (inefficiently) an arbitrary function using a logically complete set of gates. Be familiar with the logical implementation of basic architecture elements, such as adders, decoders, multiplexers, latches, registers, memories. Understand the finite state machine (FSM) abstraction of digital systems and should be able to construct a transition diagram from a gate-level circuit diagram. (a, m, n)

Computer Organization: Be familiar with the von Neumann model of computers and able to identify the role of each element (control unit, processing unit, memory, input and output). Able to identify stages in instruction processing (fetch, decode, execute) and should recognize the use of FSMs as computer control units. Understand the basics of how I/O devices to interface to computers and how software interacts with them. (a, e, n)

Assembly Programming: Able to systematically decompose a problem to the level of a computer instruction set. Able to construct iterations and should understand the concept of invariants as well as the relationship between mathematical induction and the properties established by loop iterations. Understand the use of subroutines and their role in supporting top-down decomposition of problems, and should have some experience in designing and using them for this purpose. Understand the general process by which programs written in high-level languages are compiled into assembly language and then assembled into machine code. Hands on-experience using the basic tools employed for modern software development, including editors, compilers, assemblers, simulators, and debuggers. (a, e)

Basics of C Programming: Understand the idea of scope and storage for variables in high-level languages. Understand the role of types in high-level languages in providing information to the compiler. Understand how statements in high-level language such as C are transformed into machine code, and should be able to perform such transformations by hand. (a, e)

Functions in C Programming: Understand the stack abstraction and its role in supporting the transfer of information between a caller and a subroutine. Understand the notion of a calling convention and should be able to implement linkage necessary to a convention for any given subroutine. (a, e)

Arrays and Pointers: Hands-in experience using arrays and pointers, and should understand their representations in memory. (a, e)

Data Structures: Understand the role of data structures in representing information, should have experience in using them, and should understand their representation in memory. Understand dynamic memory allocation and should have experience using it. (a, e)

Recursion: Understand the value of recursion as a problem-solving tool, should be able to describe the general form of a recursive function, and should be able to develop recursive functions to solve specific problems. (a, e)

Debugging and Testing: Understand the ambiguous nature of problem statements how such ambiguity can lead to errors in program, specification and implementation, and how to reduce the likelihood of such errors. Experience with the process of developing and applying simple tests to ensure that software works as intended. Familiarity with debugging tools and their role in identifying, isolating, and correcting errors in software. Understand the importance and ethical implications of proper testing and error handling as it pertains to reducing the likelihood of software errors and failures. Individual experience in transforming a problem specification into a working software solution, including the testing process, without contributions from other sources (i.e., not in the context of an existing program). (a, c, e, f, k)

Last updated: 5/27/2013 by Sanjay J. Patel