Composing Programs Notes

Abstract

Welcome to Composing Programs, a free online introduction to programming and computer science.

In the tradition of SICP, this text focuses on methods for abstraction, programming paradigms, and techniques for managing the complexity of large programs. These concepts are illustrated primarily using the Python 3 programming language.

In addition to reading the chapters below, you can apply your knowledge to the programming projects that accompany the text and visualize program execution using the Online Python Tutor.

Instructors: If you are interested in adapting any of these materials for your courses, please fill out this short survey so that we can support your efforts.

From: http://www.composingprograms.com/ Composing Programs by John DeNero, based on the textbook Structure and Interpretation of Computer Programs by Harold Abelson and Gerald Jay Sussman, is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.

Structure

Chapter 1: Building Abstractions with Functions

• 1.1 Getting Started
• 1.2 Elements of Programming
• 1.3 Defining New Functions
• 1.4 Designing Functions
• 1.5 Control
• 1.6 Higher-Order Functions
• 1.7 Recursive Functions

Chapter 2: Building Abstractions with Data

• 2.1 Introduction
• 2.2 Data Abstraction
• 2.3 Sequences
• 2.4 Mutable Data
• 2.5 Object-Oriented Programming
• 2.6 Implementing Classes and Objects
• 2.7 Object Abstraction
• 2.8 Efficiency
• 2.9 Recursive Objects

Chapter 3: Interpreting Computer Programs

• 3.1 Introduction
• 3.2 Functional Programming
• 3.3 Exceptions
• 3.4 Interpreters for Languages with Combination
• 3.5 Interpreters for Languages with Abstraction

Chapter 4: Data Processing

• 4.1 Introduction
• 4.2 Implicit Sequences
• 4.3 Declarative Programming
• 4.4 Logic Programming
• 4.5 Unification
• 4.6 Distributed Computing
• 4.7 Distributed Data Processing
• 4.8 Parallel Computing

Tree

.
├── exercises
│   ├── cap-1
│   │   ├── advanced.py
│   │   ├── basic.py
│   │   └── intermediate.py
│   ├── cap-2
│   │   ├── advanced.py
│   │   ├── basic.py
│   │   └── intermediate.py
│   ├── cap-3
│   │   ├── advanced.py
│   │   ├── basic.py
│   │   └── intermediate.py
│   └── cap-4
│       ├── advanced.py
│       ├── basic.py
│       └── intermediate.py
├── lectures
│   ├── cap-1
│   │   ├── control.py
│   │   ├── defining_functions.py
│   │   ├── defining_new_functions.py
│   │   ├── elements_of_programming.py
│   │   ├── getting_started.py
│   │   ├── higher_order_functions.py
│   │   └── recursive_functions.py
│   ├── cap-2
│   │   ├── data_abstraction.py
│   │   ├── efficiency.py
│   │   ├── implementing_classes_and_objects.py
│   │   ├── introduction.py
│   │   ├── mutable_data.py
│   │   ├── object_abstraction.py
│   │   ├── object_oriented_programming.py
│   │   ├── recursive_objects.py
│   │   └── sequences.py
│   ├── cap-3
│   │   ├── exception.py
│   │   ├── functional_programming.py
│   │   ├── interpreters_for_languages_with_combination.py
│   │   ├── interpreters_for_language_with_abstraction.py
│   │   └── introduction.py
│   └── cap-4
│       ├── declarative_programming.py
│       ├── distributed_computing.py
│       ├── distributed_data_processing.py
│       ├── implicit_sequences.py
│       ├── introduction.py
│       ├── logic_programming.py
│       ├── parallel_computing.py
│       └── unification.py
├── LICENSE
└── README.md

10 directories, 43 files

Collaboration

You can try create a new PR adding exercises based on the structure above.

I advise you to use hub for handling PRs with the command line, but you can also use the GitHub GUI.

hub fork
git checkout -b exercise-cap1-basic
git add .
git commit
git push
hub pull-request

License

MIT