Phones, diesel engines, animated newspapers, medical devices, games, political
campaigns, medical research, mining, transportation systems, ... and so
on, and on, and on... every day more of the world around us is at least
partly run by computer programs. This means that being able to design programs
- or at least be able to work with people who design programs - is becoming
a more and more valuable skill.
To build your own programs you need to know two things: how to use the
specific programming language and libraries needed, and the more general
skill of how to design a program.
This course presents a design method that will enable you to approach
the design of complex programs systematically. The method will work for
programs in this course as well as hard to design programs you develop
in the future.
Using this method you will learn how to model the information in a problem
domain, how to structure program data to mirror that information and how
to further structure the data to lead to a well organized program. You
will also learn to distinguish those parts of a program that are naturally
data driven, from those that should use an alternative algorithmic approach.
The method uses unit-tests to both produce a better developed design, and
to test your program as you develop it.
In the first course -- Part 1 -- we use a simple
teaching language to cover the core of the design method. In Part 1 we cover various forms of data; simple interactive programs like games and animations; storing information in and rendering trees; and finally exploring search programs: programs that solve puzzles like Sudoku boards.
A second phase of the course, to be offered later, will consist of parallel tracks, with each track using a different popular
programming language and focusing on a different kind of problem. This
will help you bring the design method to whatever language and problem
domain interests you.
Week One: Introduction and the structure of the course. The Beginning
Student Language; expressions and evaluation rules; primitive
operations on numbers, strings and images. The How to Design Functions
Week Two: Representing information as data. The How to Design Data
(HtDD) recipe. Atomic forms of data including intervals, enumerations,
Week Three: The design of simple interactive programs. The big-bang
user interface framework. The How to Design Worlds (HtDW)
recipe. Representing information where two or more values naturally
form a whole using compound data.
Week Four: Representing arbitrary sized information using
lists. Decomposition of information into multiple types.
Week Five: Functions operating on natural numbers. A parlor
trick. Rules for decomposing functions.
Week Six: List abbreviations. Mutual reference allows more complex
arbitrary-sized data. Using binary trees to enable fast lookup of
information. Using arbitrary arity trees to represent inherently
Week Seven: Functions that consume two arguments that have 'one-of' in
their types. Using local definitions to improve the structure of
Week Eight: Using abstraction to control reduce repetition and
complexity in programs.
Week Nine: Generative recursion, fractals and search problems.
This course is aimed at novices, but I still got some useful things out of it. I ended up skipping most of the work towards the end due to the slow pace, but I really like the systemic approach the Prof used. The course used a language called Racket (a scheme variant), and I think that was a good thing. It eliminated syntax-related distractions and really made the data and functions clearer. The course was very well-contained and had no unspoken pre-requisites. On the contrary, it was the students coming in with a background in Java or similar languages who struggled, not the beginners! At least that’s what it looked like from the forums. This was probably only a problem for those who were set in their ways.
Yuriycompleted this course, spending 6 hours a week on it and found the course difficulty to be medium.
This course best introducing to CS. Also you get introduction to functional programming and test-driven-development and data-driven-development.Course overall is easy ,if you will read course book (which is free on-line). All you need to know are primitives and expressions which cover in week1. Also you get a recipes how to build complex function from scratch systematically.