コミット: ae8be4c5ebe331e8782c89153137ed4095c0d505 - course-materials (hg)

コミットメタ情報

• リビジョン: ae8be4c5ebe331e8782c89153137ed4095c0d505 (tree)
• 日時: 2020-11-12 23:23:38
• 作者: H. Turgut Uyar <uyar@teki...>
• コミッター: H. Turgut Uyar

ログメッセージ

add transcripts and metadata to programming slides

変更サマリ

• modified: .hgignore
• modified: 2.programming/1.definition/slides.en.rst
• modified: 2.programming/2.language-processors/slides.en.rst
• add: 2.programming/1.definition/meta.yml
• add: 2.programming/1.definition/transcript.txt
• add: 2.programming/2.language-processors/meta.yml
• add: 2.programming/2.language-processors/transcript.txt

差分

diff -r e24a11b27f11 -r ae8be4c5ebe3 .hgignore
--- a/.hgignore	Thu Nov 12 14:57:09 2020 +0300
+++ b/.hgignore	Thu Nov 12 17:23:38 2020 +0300
@@ -4,5 +4,7 @@
 *.css
 *.css.map
 *.js
+*.pdf
+*.zip
 
 .sass-cache

diff -r e24a11b27f11 -r ae8be4c5ebe3 2.programming/1.definition/meta.yml
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/2.programming/1.definition/meta.yml	Thu Nov 12 17:23:38 2020 +0300
@@ -0,0 +1,6 @@
+requires:
+  - processor
+  - hexadecimal-notation
+
+provides:
+  - programming-definition

diff -r e24a11b27f11 -r ae8be4c5ebe3 2.programming/1.definition/slides.en.rst
--- a/2.programming/1.definition/slides.en.rst	Thu Nov 12 14:57:09 2020 +0300
+++ b/2.programming/1.definition/slides.en.rst	Thu Nov 12 17:23:38 2020 +0300
@@ -30,7 +30,7 @@
 ..
 
 * instructions encoded as numbers
-* `depends on the processor type <annotate://box/orange>`_
+* `depends on the processor <annotate://box/orange>`_
 
 ----
 
@@ -52,11 +52,14 @@
 
 ----
 
-High-Level Languages
-====================
+Source Code
+===========
 
 * very difficult to write machine code directly
 
+  * what instructions are available?
+  * in which memory locations are the data?
+
 ..
 
 * write program in a friendlier language
@@ -66,14 +69,26 @@
 
 .. class:: substep
 
-* use a program to convert source code to machine code
+* use a program to convert it to machine code
+
+----
+
+Friendlier?
+===========
+
+* more abstract concepts
+
+..
+
+* using names instead of numbers to refer to memory locations
+* grouping multiple instructions into `statements <annotate://underline/orange>`_
 
 ----
 
 Conversion to Machine Code
 ==========================
 
-* source code doesn't depend on processor type
+* source code doesn't depend on processor
 * but machine code does
 
 ..

diff -r e24a11b27f11 -r ae8be4c5ebe3 2.programming/1.definition/transcript.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/2.programming/1.definition/transcript.txt	Thu Nov 12 17:23:38 2020 +0300
@@ -0,0 +1,208 @@
+Programming
+===========
+
+Let's look at the definition of a computer program.
+This definition is taken from Wikipedia,
+but you can find similar definitions in many resources.
+
+Let's first read the full definition and then go over it:
+
+"A computer program is a collection of instructions
+ that can be executed by a computer
+ to perform a specific task."
+
+The first part tells us that a program consists of instructions.
+Do this, then do that, then do that, and so on.
+
+The second part tells that these instructions are meant to be executed
+by a computer.
+So they must be things that the computer "understands",
+in other words, knows how to carry out.
+
+And the third part tells that the program will perform a specific task,
+like solving a particular problem.
+
+[PRESS ENTER TO PROCEED TO SUBSTEP]
+
+And we can define programming
+as the act of designing and implementing computer programs.
+
+----
+
+Machine Code
+============
+
+We said that programs consist of instructions to the computer.
+We call this collection of all instructions that make up the program
+the "machine code" of that program.
+
+Since computers can basically only work with numbers,
+everything needs to be somehow represented by numbers.
+This includes the instructions to the computer,
+and also all of the operands that these instructions will work on.
+
+The component of the computer that carries out instructions is its processor.
+There are many different processors
+which have been manufactured by different companies.
+These different processors can understand different instructions.
+Even if they have the same instruction,
+the number they use to represent the instruction will be different.
+Therefore the machine code will be different between different processors,
+in other words, [CLICK ON] it depends on the processor.
+
+----
+
+Machine Code Example
+====================
+
+Let's look at an example.
+Say, given what year we're in and the birth year of a person,
+we want to figure out if that person is under the age of 18 or not.
+
+We can express this calculation like this:
+
+Get the value located in memory address 47 into the processor.
+Here we are assuming that this memory location contains the current year.
+
+Subtract the value located in memory address 62 from that year value.
+We are assuming that the person's birth year is stored in that location.
+The result of the subtraction will be the age of the person.
+
+Check whether the result is less than 18.
+If it is, continue with the instruction that is located
+4 positions ahead from the current memory location.
+
+Now let's see how these instructions can be represented in machine code
+on some processor.
+
+[PRESS ENTER TO PROCEED TO SUBSTEP]
+
+Here we are using hexadecimal notation.
+If we look closely, we can roughly understand how this code is structured.
+
+For example, the decimal number 47 is represented as 2F in hexadecimal
+(2 times 16 makes 32, plus 15 makes 47).
+And the machine code starts with A12F.
+We can guess that "A1" (161 in decimal) is the number
+that represents the instruction of getting
+the value of a given memory location into the processor.
+The following six zeroes are part of this memory address.
+
+The decimal number 62 is represented as 3E in hexadecimal
+(3 times 16 makes 48, plus 14 makes 62).
+The part that starts with "2B053E" must represent the next instruction.
+So, "2B05" likely means
+"subtract the given operand (in this case, 62)
+from the value in the processor".
+Again the address "3E" is followed by six zeroes to form a full memory address.
+
+Next we have the comparison operation.
+Decimal 18 corresponds to hexadecimal 12 (16 plus 2).
+In the code "83F812",
+"83F8" likely means "compare the value in the processor with the given value"
+(in this case, 18).
+
+And finally, in the remaining part "7C04",
+the code "7C" must mean something like
+"if the value in the processor is less (as a result of this comparison),
+continue with instruction which is the given number of positions ahead".
+And "04" is the number of positions.
+
+----
+
+Source Code
+===========
+
+You can see that it's very difficult to write code like this.
+We have to know what the available instructions are,
+what operands they take, where every piece of data is, and so on.
+
+So, the idea is: "let's write our code in a friendlier (or easier) language".
+We call this code the "source code" of the program.
+
+[PRESS ENTER TO PROCEED TO SUBSTEP]
+
+And then we use a program that will convert this source to machine code.
+
+----
+
+Friendlier?
+===========
+
+But, what does "friendlier" mean?
+What makes a language friendly?
+
+In this context, friendliness refers to the ability to use
+more abstract concepts rather than the platform details.
+
+For example, instead of having to know at which memory location
+some data is, we could use a name for the data
+and the convertor would figure out the actual memory address.
+
+Or, instead of having to know how to carry out a subtraction operation,
+we could express it using the familiar mathematical notation
+and the convertor could generate the necessary instruction sequence.
+So, one [CLICK ON] statement could correspond to multiple instructions.
+
+----
+
+Conversion to Machine Code
+==========================
+
+This approach creates another opportunity for us.
+Since we're not dealing with what instructions the processor can understand,
+our source code doesn't have to depend on the processor anymore.
+
+But -as we have discussed- the machine code does depend on the processor,
+therefore our convertor has to take our source code
+and generate the proper machine code [CLICK ON] for a particular processor.
+
+[PRESS ENTER TO PROCEED TO SUBSTEP]
+
+But the nice thing is, as programmers, we don't care
+how this conversion is made.
+
+----
+
+Portability
+===========
+
+If we sum it up, we write our processor-independent source code
+and we use an appropriate convertor to generate machine code from it.
+
+If we want to generate machine code for another processor,
+we have to find another convertor that can do this for us.
+But ideally, we shouldn't have to change our source code.
+If that is the case, we say that our source code is "portable".
+
+[PRESS ENTER TO PROCEED TO SUBSTEP]
+
+Unfortunately, it's not just the processor differences
+that prevents source code from being portable.
+Other factors, most importantly the operating system
+on which the program will run, also play significant roles.
+So, instead of "processor-independent",
+we use the term "platform-independent"
+where the term platform indicates the processsor and the operating system,
+and possibly other factors.
+
+----
+
+Language Levels
+===============
+
+When we've discussed the difficulties of writing our programs directly
+in machine code,
+we've used the term "friendlier" language.
+This "friendliness" of a language is in fact on a scale,
+and it's called the "level" of a language.
+
+Languages where the programmer has to be more familiar with the details
+of the platform are called "lower-level languages" (so, less friendly).
+And languages where the source code is closer to the way humans think
+and express themselves are called "higher-level languages".
+
+These are loose definitions and there's no well defined scale
+that ranks languages based on these criteria.
+But generally, a language that is reasonably easy to understand
+and to write source code in, is called a "high-level" language.

diff -r e24a11b27f11 -r ae8be4c5ebe3 2.programming/2.language-processors/meta.yml
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/2.programming/2.language-processors/meta.yml	Thu Nov 12 17:23:38 2020 +0300
@@ -0,0 +1,2 @@
+requires:
+  - programming-definition

diff -r e24a11b27f11 -r ae8be4c5ebe3 2.programming/2.language-processors/slides.en.rst
--- a/2.programming/2.language-processors/slides.en.rst	Thu Nov 12 14:57:09 2020 +0300
+++ b/2.programming/2.language-processors/slides.en.rst	Thu Nov 12 17:23:38 2020 +0300
@@ -11,9 +11,9 @@
 
    * interpreting:
 
-     * convert first instruction
+     * convert first statement
      * execute it
-     * convert next instruction
+     * convert next statement
      * execute it
      * ...
 
@@ -23,8 +23,8 @@
 
      * | convert whole source code
        | into executable code
-     * execute first instruction
-     * execute next instruction
+     * execute first statement
+     * execute next statement
      * ...
 
 ----

diff -r e24a11b27f11 -r ae8be4c5ebe3 2.programming/2.language-processors/transcript.txt
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/2.programming/2.language-processors/transcript.txt	Thu Nov 12 17:23:38 2020 +0300
@@ -0,0 +1,75 @@
+Conversion Methods
+==================
+
+There are two ways to convert and run a source code.
+
+In the interpretation approach, the source code is processed
+statement by statement.
+That means, the first statement gets read, converted, and executed.
+And then the next statement gets read, converted, and executed.
+And it continues like this until the program terminates.
+
+In the compilation approach, the source code is processed as a whole.
+First, the entire source code is converted to machine code,
+that is, all statements are converted at once,
+and then they are executed in sequence.
+
+----
+
+Interpreting
+============
+
+This diagram shows the stages of interpreted execution.
+Both the source code and the inputs are fed into the interpreter
+which does both the conversion and the execution,
+and produces the outputs.
+
+[PRESS ENTER TO PROCEED TO SUBSTEP]
+
+The conversion from source code to machine code is done
+while the program is running
+-using the technical term, "at runtime".
+
+Interpretation is more flexible than compilation
+because not everything has to be decided up front.
+
+----
+
+Compiling
+=========
+
+In the compilation method, the conversion and execution -or "running"-
+stages are separated.
+The source code is fed into the compiler which produces the machine code.
+And then the machine code and inputs are fed into the executor
+which produces the outputs.
+
+Here, the conversion is done at "compile time".
+
+Compilation is significantly faster than interpretation
+because the conversion is already finished before the program starts running.
+
+----
+
+Programmer's Workflow
+=====================
+
+To sum up, here's how programmers develop programs:
+
+First, they write some source code.
+
+Then, if using a compiled language, they run it through the compiler
+to generate machine code.
+
+If there are any errors in the code that prevent the compiler
+from generating the machine code, they go back to editing the source code.
+
+If the compiler doesn't give any errors and does generate a machine code,
+they run the machine code and check whether the program behaves the way
+it's expected to behave or not,
+like producing correct outputs for given inputs.
+Note that, just because the compiler didn't give any errors
+it doesn't mean that the program will work as intended.
+And if the program doesn't work correctly,
+it's time to figure out what's causing the problem
+and go back to editing the source code.