|Use this page to maintain syllabus information, learning objectives, required materials, and technical requirements for the course.|
|CS 2500 - Fundamentals of Computer Science 1|
Fall 2016 Semester
The language Scheme is actually an implementation of one of the two bedrock foundations of the theory of computer science, namely, the lambda calculus of Alonzo Church defined in the 1930s. Church showed how the definition of functions which he called lambdas could be used to describe all computations that could be systematically executed.
The design recipe of the course first teaches students how to work with atomic entities such as numbers and symbols. The next step is "named collections" in which each component is identified by a name. The next step after that is lists. In a list, you may name the list itself, the first item in the list, and the rest of the list. You cannot directly name all of the items in the list. Instead, you must learn list traversal in order to get at and process all of the list items. Once you have lists, you can then construct lists-of-lists, trees, graphs, or any other complex data structure you might require. The design reciple continues to provide the formal guidance for designing functions to traverse these complex structures. The pinnacle of the design process in when the data being acted upon are functions or even combinations of functions and other kinds of data.
This summary should explain why and how formal reasoning is fully embedded in the course.
This course is an introduction to computing and programming. Its major goal is to introduce students to the principles of systematic problem solving through programming and the basic rules of computation.
The course uses the functional programming language Scheme which is better suited to teaching the principles of design than many commercial languages. The textbook teaches a "design recipe" that leads students to structure the behavior of a function in parallel to the structure of the data on which it will act. The design recipe promotes the idea that a complex function should not try to do everything inside itself. Rather, a complex function should call on one or more simpler functions to help with its work. A complex function may also use "recursion", that is, call on itself but pass to itself a simpler instance of the data on which it is working. In that way, after many stages, a complex problem may be reduced to trivial cases in which the work may be done directly. The language views a function definition to be a data object. This enables "meta-programming" in which a supervisor function may run a standard type of task but vary the details based on whatever specific function is passed to it as its data.
The design ideas in this course bring students to an advanced level very quickly. They also provide an intellectual perspective that permits the student to later understand the strengths and weaknesses of more traditional commercial language.
|Return to Previous||New Search|