The goal of this book is to teach you to think like a computer scientist. This
+ way of thinking combines some of the best features of mathematics, engineering,
+ and natural science. Like mathematicians, computer scientists use formal
+ languages to denote ideas (specifically computations). Like engineers, they
+ design things, assembling components into systems and evaluating tradeoffs
+ among alternatives. Like scientists, they observe the behavior of complex
+ systems, form hypotheses, and test predictions.
+
The single most important skill for a computer scientist is problem
+ solving. Problem solving means the ability to formulate problems, think
+ creatively about solutions, and express a solution clearly and accurately. As
+ it turns out, the process of learning to program is an excellent opportunity to
+ practice problem solving skills. That's why this chapter is called, The Way of
+ the Program.
+
On one level, you will be learning to program, a useful skill by itself. On
+ another level, you will use programming as a means to an end. As we go along,
+ that end will become clearer.
+ Natural languages are the languages that people speak, such as English,
+ Spanish, and French. They were not designed by people (although people try to
+ impose some order on them); they evolved naturally.
+
+ Formal languages are languages that are designed by people for specific
+ applications. For example, the notation that mathematicians use is a formal
+ language that is particularly good at denoting relationships among numbers and
+ symbols. Chemists use a formal language to represent the chemical structure of
+ molecules. And most importantly:
+
Programming languages are formal languages that have been designed to
+ express computations.
+
Formal languages tend to have strict rules about syntax. For example, 3+3=6
+ is a syntactically correct mathematical statement, but 3=+6$ is not.
+ H2O is a syntactically correct chemical name, but 2Zz is
+ not.
+
Syntax rules come in two flavors, pertaining to tokens and structure.
+ Tokens are the basic elements of the language, such as words, numbers, and
+ chemical elements. One of the problems with 3=+6$ is that $ is not a
+ legal token in mathematics (at least as far as we know). Similarly,
+ 2Zz is not legal because there is no element with the abbreviation
+ Zz.
+
+
The second type of syntax rule pertains to the structure of a statement—
+ that is, the way the tokens are arranged. The statement 3=+6$ is
+ structurally illegal because you can't place a plus sign immediately after an
+ equal sign. Similarly, molecular formulas have to have subscripts after the
+ element name, not before.
+
When you read a sentence in English or a statement in a formal language, you
+ have to figure out what the structure of the sentence is (although in a natural
+ language you do this subconsciously). This process is called parsing.
+
+
For example, when you hear the sentence, The other shoe fell, you understand
+ that the other shoe is the subject and fell is the verb. Once you have parsed
+ a sentence, you can figure out what it means, or the semantics of the sentence.
+ Assuming that you know what a shoe is and what it means to fall, you will
+ understand the general implication of this sentence.
+
Although formal and natural languages have many features in common — tokens,
+ structure, syntax, and semantics — there are many differences:
+
+
+ ambiguity
+
Natural languages are full of ambiguity, which people deal with by
+ using contextual clues and other information. Formal languages are
+ designed to be nearly or completely unambiguous, which means that any
+ statement has exactly one meaning, regardless of context.
+
+
+ redundancy
+
In order to make up for ambiguity and reduce misunderstandings, natural
+ languages employ lots of redundancy. As a result, they are often
+ verbose. Formal languages are less redundant and more concise.
+
+
+ literalness
+
Formal languages mean exactly what they say. On the other hand,
+ natural languages are full of idiom and metaphor. If someone says, The
+ other shoe fell, there is probably no shoe and nothing falling.
+
+
You'll need to find the original joke to understand the idiomatic
+ meaning of the other shoe falling. Yahoo! Answers thinks it
+ knows!
+
+
+
+
People who grow up speaking a natural language—everyone—often have a hard
+ time adjusting to formal languages. In some ways, the difference between formal
+ and natural language is like the difference between poetry and prose, but more
+ so:
+
+
+ poetry
+
Words are used for their sounds as well as for their meaning, and the
+ whole poem together creates an effect or emotional response. Ambiguity
+ is not only common but often deliberate.
+
+
+ prose
+
The literal meaning of words is more important, and the structure
+ contributes more meaning. Prose is more amenable to analysis than
+ poetry but still often ambiguous.
+
+
+ program
+
The meaning of a computer program is unambiguous and literal, and can
+ be understood entirely by analysis of the tokens and structure.
+
+
+
Here are some suggestions for reading programs (and other formal languages).
+ First, remember that formal languages are much more dense than natural
+ languages, so it takes longer to read them. Also, the structure is very
+ important, so it is usually not a good idea to read from top to bottom, left to
+ right. Instead, learn to parse the program in your head, identifying the tokens
+ and interpreting the structure. Finally, the details matter. Little things
+ like spelling errors and bad punctuation, which you can get away with in
+ natural languages, can make a big difference in a formal language.
+
+ Check your understanding
+
+
+
+
The differences between natural and formal languages include:
+
+
+
+
+
natural languages can be parsed while formal languages cannot.
+
+
+ Actually both languages can be parsed (determining the structure of the sentence), but formal languages can be parsed more easily in software.
+
+
+
+
+
ambiguity, redundancy, and literalness.
+
+
+ All of these can be present in natural languages, but cannot exist in formal languages.
+
+
+
+
+
there are no differences between natural and formal languages.
+
+
+ There are several differences between the two but they are also similar.
+
+
+
+
+
tokens, structure, syntax, and semantics.
+
+
+ These are the similarities between the two.
+
+
+
+
+
+
+
True or False: Reading a program is like reading other kinds of text.
+
+
+
+
+
True
+
+
+ It usually takes longer to read a program because the structure is as important as the content and must be interpreted in smaller pieces for understanding.
+
+
+
+
+
False
+
+
+ It usually takes longer to read a program because the structure is as important as the content and must be interpreted in smaller pieces for understanding.
+
+
+
+
+
diff --git a/pretext/ExtraTopics/Glossary.ptx b/pretext/ExtraTopics/Glossary.ptx
new file mode 100644
index 000000000..3bfab9e89
--- /dev/null
+++ b/pretext/ExtraTopics/Glossary.ptx
@@ -0,0 +1,156 @@
+
+
+ Glossary
+
+
+
+
+
+ activecode
+
A unique interpreter environment that allows Python to be executed from within a web browser.
+
+
+ algorithm
+
A general step by step process for solving a problem.
+
+
+ bug
+
An error in a program.
+
+
+ byte code
+
An intermediate language between source code and object code. Many
+ modern languages first compile source code into byte code and then
+ interpret the byte code with a program called a virtual machine.
+
+
+ codelens
+
An interactive environment that allows the user to control the step by step execution of a Python program
+
+
+ comment
+
Information in a program that is meant for other programmers (or anyone
+ reading the source code) and has no effect on the execution of the
+ program.
+
+
+ compile
+
To translate a program written in a high-level language into a
+ low-level language all at once, in preparation for later execution.
+
+
+ debugging
+
The process of finding and removing any of the three kinds of
+ programming errors.
+
+
+ exception
+
Another name for a runtime error.
+
+
+ executable
+
Another name for object code that is ready to be executed.
+
+
+ formal language
+
Any one of the languages that people have designed for specific
+ purposes, such as representing mathematical ideas or computer programs;
+ all programming languages are formal languages.
+
+
+ high-level language
+
A programming language like Python that is designed to be easy for
+ humans to read and write.
+
+
+ interpret
+
To execute a program in a high-level language by translating it one
+ line at a time.
+
+
+ low-level language
+
A programming language that is designed to be easy for a computer to
+ execute; also called machine language or assembly language.
+
+
+ natural language
+
Any one of the languages that people speak that evolved naturally.
+
+
+ object code
+
The output of the compiler after it translates the program.
+
+
+ parse
+
To examine a program and analyze the syntactic structure.
+
+
+ portability
+
A property of a program that can run on more than one kind of computer.
+
+
+ print function
+
A function used in a program or script that causes the Python
+ interpreter to display a value on its output device.
+
+
+ problem solving
+
The process of formulating a problem, finding a solution, and
+ expressing the solution.
+
+
+ program
+
A sequence of instructions that specifies to a computer actions and
+ computations to be performed.
+
+
+ programming language
+
A formal notation for representing solutions.
+
+
+ Python shell
+
An interactive user interface to the Python interpreter. The user of a
+ Python shell types commands at the prompt (>>>), and presses the return
+ key to send these commands immediately to the interpreter for
+ processing.
+
+
+ runtime error
+
An error that does not occur until the program has started to execute
+ but that prevents the program from continuing.
+
+
+ semantic error
+
An error in a program that makes it do something other than what the
+ programmer intended.
+
+
+ semantics
+
The meaning of a program.
+
+
+ shell mode
+
A style of using Python where we type expressions at the command
+ prompt, and the results are shown immediately. Contrast with
+ source code, and see the entry under Python shell.
+
+
+ source code
+
A program, stored in a file, in a high-level language before being compiled or interpreted.
+
+
+ syntax
+
The structure of a program.
+
+
+ syntax error
+
An error in a program that makes it impossible to parse — and
+ therefore impossible to interpret.
+
+
+ token
+
One of the basic elements of the syntactic structure of a program,
+ analogous to a word in a natural language.
+ Hi everyone, there's a bit of confusion going around with requirements.txt. This is simply a file in which you specify your project's dependencies, minus those which are already bundled into Python (e.g. csv).
+
+ You only need to provide this file if you're using external dependencies (numpy, scipy, sklearn, etc). The autograder has matplotlib bundled with it which is why you don't have to include it.
+
+ One easy way to generate this file is by running this command in the terminal (while navigated to the directory of your final project):
+
+ pip freeze > requirements.txt
+
+ Breakdown of what's happening (aside from generating the proper requirements.txt file):
+ pip is Python's dependency (aka "package") manager
+ freeze is just the command, no idea why it's called freeze. Educated guess: I think it's because it's "freezing" your dependencies at a moment in time (or in other words, at a specific version) and saving them to a file.
+ > is the Linux output redirection operator, which is going to take the result of pip freeze and redirect it to the file you provided, which is requirements.txt
+
+ That's it! Your requirements.txt will be in a format like:
+
+ numpy==1.26.2
+
+
+ (CS majors: read on for why this isn't great)
+
+ So actually, this will freeze ALL of your requirements. I ran this on my computer and had like a 100 line file of tons of dependencies, and we want people to install only what they have to (we want to minimize overhead/space taken up).
+
+ Probably the best way to do this is to pip show DEPENDENCY where DEPENDENCY is something like numpy, find the version, and type it into requirements.txt in the format listed above. There are also packages (ironically) that do this.
+
+ You can also view all packages (and their versions) that people from around the world have created on PyPI. This even includes stuff TA Greg made custom for the autograder, and is also why we made you all install Anaconda (which, for the most part, automatically dealt with this)!
+
+
+
+
+
+ Natural languages are the languages that people speak, such as English,
+ Spanish, and French. They were not designed by people (although people try to
+ impose some order on them); they evolved naturally.
+
+ Formal languages are languages that are designed by people for specific
+ applications. For example, the notation that mathematicians use is a formal
+ language that is particularly good at denoting relationships among numbers and
+ symbols. Chemists use a formal language to represent the chemical structure of
+ molecules. And most importantly:
+
Programming languages are formal languages that have been designed to
+ express computations.
+
Formal languages tend to have strict rules about syntax. For example, 3+3=6
+ is a syntactically correct mathematical statement, but 3=+6$ is not.
+ H2O is a syntactically correct chemical name, but 2Zz is
+ not.
+
Syntax rules come in two flavors, pertaining to tokens and structure.
+ Tokens are the basic elements of the language, such as words, numbers, and
+ chemical elements. One of the problems with 3=+6$ is that $ is not a
+ legal token in mathematics (at least as far as we know). Similarly,
+ 2Zz is not legal because there is no element with the abbreviation
+ Zz.
+
+
The second type of syntax rule pertains to the structure of a statement—
+ that is, the way the tokens are arranged. The statement 3=+6$ is
+ structurally illegal because you can't place a plus sign immediately after an
+ equal sign. Similarly, molecular formulas have to have subscripts after the
+ element name, not before.
+
When you read a sentence in English or a statement in a formal language, you
+ have to figure out what the structure of the sentence is (although in a natural
+ language you do this subconsciously). This process is called parsing.
+
+
For example, when you hear the sentence, The other shoe fell, you understand
+ that the other shoe is the subject and fell is the verb. Once you have parsed
+ a sentence, you can figure out what it means, or the semantics of the sentence.
+ Assuming that you know what a shoe is and what it means to fall, you will
+ understand the general implication of this sentence.
+
Although formal and natural languages have many features in common — tokens,
+ structure, syntax, and semantics — there are many differences:
+
+
+ ambiguity
+
Natural languages are full of ambiguity, which people deal with by
+ using contextual clues and other information. Formal languages are
+ designed to be nearly or completely unambiguous, which means that any
+ statement has exactly one meaning, regardless of context.
+
+
+ redundancy
+
In order to make up for ambiguity and reduce misunderstandings, natural
+ languages employ lots of redundancy. As a result, they are often
+ verbose. Formal languages are less redundant and more concise.
+
+
+ literalness
+
Formal languages mean exactly what they say. On the other hand,
+ natural languages are full of idiom and metaphor. If someone says, The
+ other shoe fell, there is probably no shoe and nothing falling.
+
+
You'll need to find the original joke to understand the idiomatic
+ meaning of the other shoe falling. Yahoo! Answers thinks it
+ knows!
+
+
+
+
People who grow up speaking a natural language—everyone—often have a hard
+ time adjusting to formal languages. In some ways, the difference between formal
+ and natural language is like the difference between poetry and prose, but more
+ so:
+
+
+ poetry
+
Words are used for their sounds as well as for their meaning, and the
+ whole poem together creates an effect or emotional response. Ambiguity
+ is not only common but often deliberate.
+
+
+ prose
+
The literal meaning of words is more important, and the structure
+ contributes more meaning. Prose is more amenable to analysis than
+ poetry but still often ambiguous.
+
+
+ program
+
The meaning of a computer program is unambiguous and literal, and can
+ be understood entirely by analysis of the tokens and structure.
+
+
+
Here are some suggestions for reading programs (and other formal languages).
+ First, remember that formal languages are much more dense than natural
+ languages, so it takes longer to read them. Also, the structure is very
+ important, so it is usually not a good idea to read from top to bottom, left to
+ right. Instead, learn to parse the program in your head, identifying the tokens
+ and interpreting the structure. Finally, the details matter. Little things
+ like spelling errors and bad punctuation, which you can get away with in
+ natural languages, can make a big difference in a formal language.
+
+ Check your understanding
+
+
+
+
The differences between natural and formal languages include:
+
+
+
+
+
natural languages can be parsed while formal languages cannot.
+
+
+ Actually both languages can be parsed (determining the structure of the sentence), but formal languages can be parsed more easily in software.
+
+
+
+
+
ambiguity, redundancy, and literalness.
+
+
+ All of these can be present in natural languages, but cannot exist in formal languages.
+
+
+
+
+
there are no differences between natural and formal languages.
+
+
+ There are several differences between the two but they are also similar.
+
+
+
+
+
tokens, structure, syntax, and semantics.
+
+
+ These are the similarities between the two.
+
+
+
+
+
+
+
True or False: Reading a program is like reading other kinds of text.
+
+
+
+
+
True
+
+
+ It usually takes longer to read a program because the structure is as important as the content and must be interpreted in smaller pieces for understanding.
+
+
+
+
+
False
+
+
+ It usually takes longer to read a program because the structure is as important as the content and must be interpreted in smaller pieces for understanding.
+
+
+
+
+
diff --git a/pretext/ExtraTopics/SearchSortAlgorithms.ptx b/pretext/ExtraTopics/SearchSortAlgorithms.ptx
new file mode 100644
index 000000000..e14eef481
--- /dev/null
+++ b/pretext/ExtraTopics/SearchSortAlgorithms.ptx
@@ -0,0 +1,93 @@
+
+
+ Search and Sort Algorithms
+
+
+
If problem solving is a central part of computer science, then the solutions that you create through
+ the problem solving process are also important. In computer science, we refer to these solutions
+ as algorithms. An algorithm is a step by step list of instructions that if followed exactly will solve the problem under consideration.
+
Our goal in computer science is to take a problem and develop an algorithm that can serve as a general solution. Once we have such a solution, we can use our computer to automate the execution. As noted
+ above, programming is a skill that allows a computer scientist to take an algorithm and represent it in
+ a notation (a program) that can be followed by a computer. These programs are written in programming languages.
+
+ Check your understanding
+
+
+
+
What is the most important skill for a computer scientist?
+
+
+
+
+
To think like a computer.
+
+
+ Computers do not think, they only do what we humans tell them to do via programs.
+
+
+
+
+
To be able to write code really well.
+
+
+ While it is necessary for most computer scientists to know how to write code, it is not the most important skill.
+
+
+
+
+
To be able to solve problems.
+
+
+ Computer scientists are all about solving problems. We use computers to automate solutions to problems and to do things faster and more accurately than we can do by hand or manually.
+
+
+
+
+
To be really good at math.
+
+
+ Computer science and math are similar in many ways and it helps to have a strong mathematical foundation, but you do not have to be good at math to be a good computer scientist.
+
+
+
+
+
+
+
An algorithm is:
+
+
+
+
+
A solution to a problem that can be solved by a computer.
+
+
+ While it is true that algorithms often do solve problems, this is not the best answer. An algorithm is more than just the solution to the problem for a computer. An algorithm can be used to solve all sorts of problems, including those that have nothing to do with computers.
+
+
+
+
+
A step by step list of instructions that if followed exactly will solve the problem under consideration.
+
+
+ Algorithms are like recipes: they must be followed exactly, they must be clear and unambiguous, and they must end.
+
+
+
+
+
A series of instructions implemented in a programming language.
+
+
+ Programming languages are used to express algorithms, but an algorithm does not have to be expressed in terms of a programming language.
+
+
+
+
+
A special kind of notation used by computer scientists.
+
+
+ Computer scientists sometimes use a special notation to illustrate or document an algorithm, but this is not the definition of an algorithm.
+
+
+
+
+
diff --git a/pretext/ExtraTopics/toctree.ptx b/pretext/ExtraTopics/toctree.ptx
new file mode 100644
index 000000000..fcae28675
--- /dev/null
+++ b/pretext/ExtraTopics/toctree.ptx
@@ -0,0 +1,9 @@
+
+
+4Extra Topics
+4
+4
+4
+4
+4
+
diff --git a/pretext/thinkcspy.ptx b/pretext/thinkcspy.ptx
index ffbb4e2c1..b9c1b6641 100644
--- a/pretext/thinkcspy.ptx
+++ b/pretext/thinkcspy.ptx
@@ -33,6 +33,8 @@
+
+
From 11145d2a29e9883e7af6f624ec81111759194832 Mon Sep 17 00:00:00 2001
From: Ethan Richards <42894274+ezrichards@users.noreply.github.com>
Date: Mon, 18 Dec 2023 10:22:50 -0700
Subject: [PATCH 02/22] Add initial Big O chapter
---
pretext/ExtraTopics/BigO.ptx | 88 ++++++++--
pretext/ExtraTopics/BinaryRepresentations.ptx | 162 -----------------
pretext/ExtraTopics/None.ptx | 6 +
pretext/ExtraTopics/Packages.ptx | 166 +-----------------
pretext/ExtraTopics/SearchSortAlgorithms.ptx | 89 +---------
pretext/ExtraTopics/toctree.ptx | 1 +
.../ExtraTopics/Figures/complexity.png | Bin 0 -> 299961 bytes
7 files changed, 82 insertions(+), 430 deletions(-)
create mode 100644 pretext/ExtraTopics/None.ptx
create mode 100644 pretext/Figures/ExtraTopics/Figures/complexity.png
diff --git a/pretext/ExtraTopics/BigO.ptx b/pretext/ExtraTopics/BigO.ptx
index 0fd900d2d..10a81e175 100644
--- a/pretext/ExtraTopics/BigO.ptx
+++ b/pretext/ExtraTopics/BigO.ptx
@@ -2,21 +2,75 @@
Big O Analysis
-
-
The goal of this book is to teach you to think like a computer scientist. This
- way of thinking combines some of the best features of mathematics, engineering,
- and natural science. Like mathematicians, computer scientists use formal
- languages to denote ideas (specifically computations). Like engineers, they
- design things, assembling components into systems and evaluating tradeoffs
- among alternatives. Like scientists, they observe the behavior of complex
- systems, form hypotheses, and test predictions.
-
The single most important skill for a computer scientist is problem
- solving. Problem solving means the ability to formulate problems, think
- creatively about solutions, and express a solution clearly and accurately. As
- it turns out, the process of learning to program is an excellent opportunity to
- practice problem solving skills. That's why this chapter is called, The Way of
- the Program.
-
On one level, you will be learning to program, a useful skill by itself. On
- another level, you will use programming as a means to an end. As we go along,
- that end will become clearer.
+
It's hard (if not impossible) to measure the performance of algorithms on a computer. We won't get
+ deep into it, but this is due to things like variable hardware between computers and just general performance of software.
+
+
This is where Big O Analysis comes in. We can measure the performance of algorithms, or their complexity,
+ in a special mathematical notation.
+
+
This mathematical notation is denoted with a capital O (a big o!) followed by parenthesis, similar to a basic algebraic f(x), though
+ it is not a function. Inside of the O() is most commonly a 1 or a n raised to some mathematical factor.
+
+
These factors have magnitude, which helps us to quantify how quick or slow an algorithm is.
+
+
From left to right, left being the quickest time and right being the slowest time, we typically see these complexities:
Something like an O(nlogn) gain in complexity might seem marginal or redundant, but it makes a
+ difference at a large scale! Imagine your favorite big tech company and how they sift through billions of
+ users in a quick amount of time.
+
+
+
+
This figure shows complexities as a graph and which ones we do and don't like. Strive to never write something worse than O(n^3)!
+
+
Take the following code as an example:
+
+
+print(1)
+
+
+
This code runs in constant time, or O(1). Constant time operations are typically
+ things in code which do not loop.
+
+
Now, let's check out an example with a loop:
+
+
+def example_func(n):
+ for i in range(n):
+ print(i)
+
+
+
As you can see, this function simply prints 0 to n. We measure the complexity of example_func as O(n)
+
+
The n here is crucial; it's the upper bound of what our function iterates to. In this example, it will always iterate all the way, but
+ in an actual program, it may not, which leads to worst case, average case, and best case complexities.
+
+
In the last code example, O(n) was the complexity for all cases, because the loop always goes to n.
+
+
Worst case complexities are the worst possible performances of our code.
+ For instance, if you're searching through your contacts list for a name in top-to-bottom fashion,
+ in the worst case you'll check all n names, and hence your search algorithm's worst case
+ is O(n). (Hint: We just described linear search!)
+
+
Average case complexities are the average performances of our code. In our
+ contact list example, the average case is also O(n), because you will probably
+ have to search through an arbitrary n names to find, say, the 31st contact, out of 100.
+
+
Best case complexities describe what happens in the best case with our code. In the contact list
+ example, the best case is O(1); the contact you were looking for was the very first name in the list!
+
+
All of these lead nicely into a future chapter where we talk about search and sort algorithms, which are
+ closely related to Big O Analysis and are an important topic in computer science.
+
+
One more important topic in Big O Analysis is simplification. You will often be asked to do
+ this on assignments. We won't get too deep into the math, but the general rules are as follows:
+
+
Constant time operations always simplify to O(1). You can't have complexities like O(3) or O(1000000).
+
+
Added constants are ignored when a larger factor is around. For instance, O(n + 1) is just O(n).
- Natural languages are the languages that people speak, such as English,
- Spanish, and French. They were not designed by people (although people try to
- impose some order on them); they evolved naturally.
-
- Formal languages are languages that are designed by people for specific
- applications. For example, the notation that mathematicians use is a formal
- language that is particularly good at denoting relationships among numbers and
- symbols. Chemists use a formal language to represent the chemical structure of
- molecules. And most importantly:
-
Programming languages are formal languages that have been designed to
- express computations.
-
Formal languages tend to have strict rules about syntax. For example, 3+3=6
- is a syntactically correct mathematical statement, but 3=+6$ is not.
- H2O is a syntactically correct chemical name, but 2Zz is
- not.
-
Syntax rules come in two flavors, pertaining to tokens and structure.
- Tokens are the basic elements of the language, such as words, numbers, and
- chemical elements. One of the problems with 3=+6$ is that $ is not a
- legal token in mathematics (at least as far as we know). Similarly,
- 2Zz is not legal because there is no element with the abbreviation
- Zz.
-
-
The second type of syntax rule pertains to the structure of a statement—
- that is, the way the tokens are arranged. The statement 3=+6$ is
- structurally illegal because you can't place a plus sign immediately after an
- equal sign. Similarly, molecular formulas have to have subscripts after the
- element name, not before.
-
When you read a sentence in English or a statement in a formal language, you
- have to figure out what the structure of the sentence is (although in a natural
- language you do this subconsciously). This process is called parsing.
-
-
For example, when you hear the sentence, The other shoe fell, you understand
- that the other shoe is the subject and fell is the verb. Once you have parsed
- a sentence, you can figure out what it means, or the semantics of the sentence.
- Assuming that you know what a shoe is and what it means to fall, you will
- understand the general implication of this sentence.
-
Although formal and natural languages have many features in common — tokens,
- structure, syntax, and semantics — there are many differences:
-
-
- ambiguity
-
Natural languages are full of ambiguity, which people deal with by
- using contextual clues and other information. Formal languages are
- designed to be nearly or completely unambiguous, which means that any
- statement has exactly one meaning, regardless of context.
-
-
- redundancy
-
In order to make up for ambiguity and reduce misunderstandings, natural
- languages employ lots of redundancy. As a result, they are often
- verbose. Formal languages are less redundant and more concise.
-
-
- literalness
-
Formal languages mean exactly what they say. On the other hand,
- natural languages are full of idiom and metaphor. If someone says, The
- other shoe fell, there is probably no shoe and nothing falling.
-
-
You'll need to find the original joke to understand the idiomatic
- meaning of the other shoe falling. Yahoo! Answers thinks it
- knows!
-
-
-
-
People who grow up speaking a natural language—everyone—often have a hard
- time adjusting to formal languages. In some ways, the difference between formal
- and natural language is like the difference between poetry and prose, but more
- so:
-
-
- poetry
-
Words are used for their sounds as well as for their meaning, and the
- whole poem together creates an effect or emotional response. Ambiguity
- is not only common but often deliberate.
-
-
- prose
-
The literal meaning of words is more important, and the structure
- contributes more meaning. Prose is more amenable to analysis than
- poetry but still often ambiguous.
-
-
- program
-
The meaning of a computer program is unambiguous and literal, and can
- be understood entirely by analysis of the tokens and structure.
-
-
-
Here are some suggestions for reading programs (and other formal languages).
- First, remember that formal languages are much more dense than natural
- languages, so it takes longer to read them. Also, the structure is very
- important, so it is usually not a good idea to read from top to bottom, left to
- right. Instead, learn to parse the program in your head, identifying the tokens
- and interpreting the structure. Finally, the details matter. Little things
- like spelling errors and bad punctuation, which you can get away with in
- natural languages, can make a big difference in a formal language.
-
- Check your understanding
-
-
-
-
The differences between natural and formal languages include:
-
-
-
-
-
natural languages can be parsed while formal languages cannot.
-
-
- Actually both languages can be parsed (determining the structure of the sentence), but formal languages can be parsed more easily in software.
-
-
-
-
-
ambiguity, redundancy, and literalness.
-
-
- All of these can be present in natural languages, but cannot exist in formal languages.
-
-
-
-
-
there are no differences between natural and formal languages.
-
-
- There are several differences between the two but they are also similar.
-
-
-
-
-
tokens, structure, syntax, and semantics.
-
-
- These are the similarities between the two.
-
-
-
-
-
-
-
True or False: Reading a program is like reading other kinds of text.
-
-
-
-
-
True
-
-
- It usually takes longer to read a program because the structure is as important as the content and must be interpreted in smaller pieces for understanding.
-
-
-
-
-
False
-
-
- It usually takes longer to read a program because the structure is as important as the content and must be interpreted in smaller pieces for understanding.
-
-
-
-
diff --git a/pretext/ExtraTopics/None.ptx b/pretext/ExtraTopics/None.ptx
new file mode 100644
index 000000000..5cc33d65e
--- /dev/null
+++ b/pretext/ExtraTopics/None.ptx
@@ -0,0 +1,6 @@
+
+
+ None
+
+
+
diff --git a/pretext/ExtraTopics/Packages.ptx b/pretext/ExtraTopics/Packages.ptx
index 747d617d8..0e0e8d605 100644
--- a/pretext/ExtraTopics/Packages.ptx
+++ b/pretext/ExtraTopics/Packages.ptx
@@ -1,7 +1,9 @@
- Packages
+ Packages and Dependencies
+
+
Hi everyone, there's a bit of confusion going around with requirements.txt. This is simply a file in which you specify your project's dependencies, minus those which are already bundled into Python (e.g. csv).
@@ -31,166 +33,4 @@
-
-
- Natural languages are the languages that people speak, such as English,
- Spanish, and French. They were not designed by people (although people try to
- impose some order on them); they evolved naturally.
-
- Formal languages are languages that are designed by people for specific
- applications. For example, the notation that mathematicians use is a formal
- language that is particularly good at denoting relationships among numbers and
- symbols. Chemists use a formal language to represent the chemical structure of
- molecules. And most importantly:
-
Programming languages are formal languages that have been designed to
- express computations.
-
Formal languages tend to have strict rules about syntax. For example, 3+3=6
- is a syntactically correct mathematical statement, but 3=+6$ is not.
- H2O is a syntactically correct chemical name, but 2Zz is
- not.
-
Syntax rules come in two flavors, pertaining to tokens and structure.
- Tokens are the basic elements of the language, such as words, numbers, and
- chemical elements. One of the problems with 3=+6$ is that $ is not a
- legal token in mathematics (at least as far as we know). Similarly,
- 2Zz is not legal because there is no element with the abbreviation
- Zz.
-
-
The second type of syntax rule pertains to the structure of a statement—
- that is, the way the tokens are arranged. The statement 3=+6$ is
- structurally illegal because you can't place a plus sign immediately after an
- equal sign. Similarly, molecular formulas have to have subscripts after the
- element name, not before.
-
When you read a sentence in English or a statement in a formal language, you
- have to figure out what the structure of the sentence is (although in a natural
- language you do this subconsciously). This process is called parsing.
-
-
For example, when you hear the sentence, The other shoe fell, you understand
- that the other shoe is the subject and fell is the verb. Once you have parsed
- a sentence, you can figure out what it means, or the semantics of the sentence.
- Assuming that you know what a shoe is and what it means to fall, you will
- understand the general implication of this sentence.
-
Although formal and natural languages have many features in common — tokens,
- structure, syntax, and semantics — there are many differences:
-
-
- ambiguity
-
Natural languages are full of ambiguity, which people deal with by
- using contextual clues and other information. Formal languages are
- designed to be nearly or completely unambiguous, which means that any
- statement has exactly one meaning, regardless of context.
-
-
- redundancy
-
In order to make up for ambiguity and reduce misunderstandings, natural
- languages employ lots of redundancy. As a result, they are often
- verbose. Formal languages are less redundant and more concise.
-
-
- literalness
-
Formal languages mean exactly what they say. On the other hand,
- natural languages are full of idiom and metaphor. If someone says, The
- other shoe fell, there is probably no shoe and nothing falling.
-
-
You'll need to find the original joke to understand the idiomatic
- meaning of the other shoe falling. Yahoo! Answers thinks it
- knows!
-
-
-
-
People who grow up speaking a natural language—everyone—often have a hard
- time adjusting to formal languages. In some ways, the difference between formal
- and natural language is like the difference between poetry and prose, but more
- so:
-
-
- poetry
-
Words are used for their sounds as well as for their meaning, and the
- whole poem together creates an effect or emotional response. Ambiguity
- is not only common but often deliberate.
-
-
- prose
-
The literal meaning of words is more important, and the structure
- contributes more meaning. Prose is more amenable to analysis than
- poetry but still often ambiguous.
-
-
- program
-
The meaning of a computer program is unambiguous and literal, and can
- be understood entirely by analysis of the tokens and structure.
-
-
-
Here are some suggestions for reading programs (and other formal languages).
- First, remember that formal languages are much more dense than natural
- languages, so it takes longer to read them. Also, the structure is very
- important, so it is usually not a good idea to read from top to bottom, left to
- right. Instead, learn to parse the program in your head, identifying the tokens
- and interpreting the structure. Finally, the details matter. Little things
- like spelling errors and bad punctuation, which you can get away with in
- natural languages, can make a big difference in a formal language.
-
- Check your understanding
-
-
-
-
The differences between natural and formal languages include:
-
-
-
-
-
natural languages can be parsed while formal languages cannot.
-
-
- Actually both languages can be parsed (determining the structure of the sentence), but formal languages can be parsed more easily in software.
-
-
-
-
-
ambiguity, redundancy, and literalness.
-
-
- All of these can be present in natural languages, but cannot exist in formal languages.
-
-
-
-
-
there are no differences between natural and formal languages.
-
-
- There are several differences between the two but they are also similar.
-
-
-
-
-
tokens, structure, syntax, and semantics.
-
-
- These are the similarities between the two.
-
-
-
-
-
-
-
True or False: Reading a program is like reading other kinds of text.
-
-
-
-
-
True
-
-
- It usually takes longer to read a program because the structure is as important as the content and must be interpreted in smaller pieces for understanding.
-
-
-
-
-
False
-
-
- It usually takes longer to read a program because the structure is as important as the content and must be interpreted in smaller pieces for understanding.
-
-
-
-
diff --git a/pretext/ExtraTopics/SearchSortAlgorithms.ptx b/pretext/ExtraTopics/SearchSortAlgorithms.ptx
index e14eef481..5909ff91a 100644
--- a/pretext/ExtraTopics/SearchSortAlgorithms.ptx
+++ b/pretext/ExtraTopics/SearchSortAlgorithms.ptx
@@ -2,92 +2,5 @@
Search and Sort Algorithms
-
-
If problem solving is a central part of computer science, then the solutions that you create through
- the problem solving process are also important. In computer science, we refer to these solutions
- as algorithms. An algorithm is a step by step list of instructions that if followed exactly will solve the problem under consideration.
-
Our goal in computer science is to take a problem and develop an algorithm that can serve as a general solution. Once we have such a solution, we can use our computer to automate the execution. As noted
- above, programming is a skill that allows a computer scientist to take an algorithm and represent it in
- a notation (a program) that can be followed by a computer. These programs are written in programming languages.
-
- Check your understanding
-
-
-
-
What is the most important skill for a computer scientist?
-
-
-
-
-
To think like a computer.
-
-
- Computers do not think, they only do what we humans tell them to do via programs.
-
-
-
-
-
To be able to write code really well.
-
-
- While it is necessary for most computer scientists to know how to write code, it is not the most important skill.
-
-
-
-
-
To be able to solve problems.
-
-
- Computer scientists are all about solving problems. We use computers to automate solutions to problems and to do things faster and more accurately than we can do by hand or manually.
-
-
-
-
-
To be really good at math.
-
-
- Computer science and math are similar in many ways and it helps to have a strong mathematical foundation, but you do not have to be good at math to be a good computer scientist.
-
-
-
-
-
-
-
An algorithm is:
-
-
-
-
-
A solution to a problem that can be solved by a computer.
-
-
- While it is true that algorithms often do solve problems, this is not the best answer. An algorithm is more than just the solution to the problem for a computer. An algorithm can be used to solve all sorts of problems, including those that have nothing to do with computers.
-
-
-
-
-
A step by step list of instructions that if followed exactly will solve the problem under consideration.
-
-
- Algorithms are like recipes: they must be followed exactly, they must be clear and unambiguous, and they must end.
-
-
-
-
-
A series of instructions implemented in a programming language.
-
-
- Programming languages are used to express algorithms, but an algorithm does not have to be expressed in terms of a programming language.
-
-
-
-
-
A special kind of notation used by computer scientists.
-
-
- Computer scientists sometimes use a special notation to illustrate or document an algorithm, but this is not the definition of an algorithm.
-
-
-
-
+
diff --git a/pretext/ExtraTopics/toctree.ptx b/pretext/ExtraTopics/toctree.ptx
index fcae28675..15cab35c6 100644
--- a/pretext/ExtraTopics/toctree.ptx
+++ b/pretext/ExtraTopics/toctree.ptx
@@ -1,6 +1,7 @@
4Extra Topics
+4
4
4
4
diff --git a/pretext/Figures/ExtraTopics/Figures/complexity.png b/pretext/Figures/ExtraTopics/Figures/complexity.png
new file mode 100644
index 0000000000000000000000000000000000000000..5914ca96da43d0abd96484387bd3f88471e0466a
GIT binary patch
literal 299961
zcmZs?c_5VG+xJam$(EEQ%w!2kWXW!9F=R_BWX-PZJIxS^Y%{h(_K;AvBqBS**tZ({
zzD;9ij2Xjw`905lzt8i&_n*vM*L7a!oab>K-_P+qVjdbonJ!(wL_tBpq^ooP5d{U+
z8w!dGPw8lY|4pAOs#8+Fzj5Q;vh58K^~+QjlCK6NF-q&N`!&s(96_8*
zS$@6>Nzd5I*(%K#eNv1~I4kwVeoOKACKAiPoXXlw=RhrWfh#;-P5XvG;{X2Bo;m!3
zvBO5~Lyfe|nd_h`Y%D``!Nc)pxa7
zfx$>l?oMp}U$6dOH|Ka0%=kad3|F{hEHD_vFk;Zd`Tsw0T;Yv3`t1MTiTtm-0Yi&7
zrrwM2iVuJVDE&{fx_t3Di0c3N`hP#$Hl9C`0@Bl_BqpqsY7195(oNDG;Ab9w4)@ln(Cs@B(1bkRudz`#JYo0X{Z*R
zB=x5KVS2)q>D2%6N$DuQ)XG)G9l^W5aF8z(8qa~FBBpjU`4?RLc);m{D{9*C{Jx*&
zJ`$Hga?L>;IfXo$OnTG>cE7hh2>sXJ83pgPva(uHP8pdn^!R=R2wfjCuPEtz&MMuIYW!`aH)+^=D(mG!>G;o|KBre$
zl<}}GjDcJwzrw7$1?R)PlZbv$E+$(X=OVDtymkY>n;qbFVGfVS*BPl)cSZ%Q_mo7V
zLd`k7o;{S6a!&3@h1gQv_O^NW>-#jYo@^cX9^T$FR;>v{>;);
zJVG~w59ry1?$?Sky&p=PPf3Fdha6sEyj$5Y`d_+LJs+hw|!ZE?da_?II!LmZh2
zHd!At_tT_^O1Z;Z{Lzv#;29li=^xqNL%5Sjqp?g=vd%wVy?z%rO?C!DcBH*Zcnrat
z(aExl_^$gD>3F_U#g0y4d)f4F`||{|gKn7&3hGB7mYe)(Xbewi^z|ocVy&MW35)v|
zv1J^f<1eAs!Bw2yaIa4`mOS-FHba57`qkM|J_}sfyi3^|n2kYI*o_T_+Tw7j!;MhE
zfv_kZN{)3rEm?OjD+zy?$Ss$9RZ)8mecZdx7aXf~DBm*X_x1aBy*H#@(!tKDFP&9l
zE4ayZ^>$M@?GiOC-;r5I;!-SSeYJ>^sr+hGUlnVqNT-~=l!nr+%=fIE7tUXRP7TyA
zny!|0KPxN4wv^!_R>$?BK(4~3;h$ShhGwqJMv6Up6sAE^zxD;1c6ZGX>mT5n7|9PNK>WNbd%1i2G9n?=+SdAt*A7NV
zf$gqigrZQ0kdu&`kUdo(ledp7=Nsk_j%3fqU2ValSzY>^G@DQb*aCwM-R*BRkG_VT
zk>f6GJ8^zIKCrjXk{Af^Ycz2vc6X)s4
znrfQqX?9I^#~i-)=S6m(vWlh~?c$DpwN)>y
zsD77HWt+*`yYt$@68J2L3#OikPH(oBupDWjWb8alf`aJfW`peOmJmv9`-7@r5NxNl
zC0lw2hEkekeQF)NQn?Vt9n~*4rwqf{gX0F;JSpDt5bZ>E@4ahhmL+8?>4ye)lPYE%T73??9JFtFSji(_oOT-Tws*$=ev6Hjjg$AaVP!4uEb{WpL7jru+a
zQKGS&*S%rraak=Rm1bQ}tm?k}dR}DPDQO!lqWLnB0)9PDoDOD1SNgXliGmQpAWp|&
zN=|y|0b+V^$PPxXj%(GowMijbJ;1Se9J>e#mJu
z`1Z(Bg0P4+{BXSP^&)?U&5R?gSb5)xJmlqz__fohpOD
z6-WegWzW4s7zgXu=~wFu34yo0b7iNpYbK(PPWA^`%D&Y;lV8j7MPCG`TyYm%&p5ba
zQ87!}YN#l@`Q@=uDVw!>+f%lX(wLYl*6XF4Pcoj&=Fk2$^kKuN&|N*-OKW~(6)