Misplaced Pages

#156843

57-542: TUTOR was originally developed as a special purpose authoring language for designing instructional lessons, and its evolution into a general purpose programming language was unplanned. The name TUTOR was first applied to the authoring language of the PLATO system in the later days of Plato III. The first documentation of the language, under this name, appears to have been Avner, Richard Allen; Tenczar, Paul (January 1969), The TUTOR Manual. CERL Report X-4 The article Teaching

114-508: A and b can also be seen as the Hamming weight of a − b for an appropriate choice of the − operator, much as the difference between two integers can be seen as a distance from zero on the number line. For binary strings a and b the Hamming distance is equal to the number of ones ( population count ) in a XOR b . The metric space of length- n binary strings, with the Hamming distance,

171-474: A used above must not have any previous definition. Later in the development of TUTOR, with the introduction of multiple named sets of definitions, the programmer was given explicit control over which sets of definitions were currently in force. For example, define purge, setname would discard all definitions in the named set. The original TUTOR tools for text manipulation were based on commands for specific text operations, for example, pack to place

228-408: A complete system to be designed without writing any programming code, although the authoring language is there for more in-depth usage. This article related to a type of software is a stub . You can help Misplaced Pages by expanding it . Hamming distance In information theory , the Hamming distance between two strings or vectors of equal length is the number of positions at which

285-403: A condition tag that indicates when the indicated control transfer is to take place. This makes the construct more powerful than in other languages, because any line of the inner loop could terminate or reloop several outer loops with one statement. TUTOR's expression syntax did not look back to the syntax of FORTRAN , nor was it limited by poorly designed character sets of the era. For example,

342-452: A packed character string into consecutive variables in memory, search to search for one string within another, and move to move a string from memory to memory. By 1975, more general tools for arrays of integers and packed arrays were added. For example: Segmented arrays , defined with the keyword segment , were comparable to packed arrays in Pascal . The byte size and whether or not

399-653: A pre-defined constant named with the Greek letter pi (π), with the appropriate value, which could be used in calculations. Thus, the expression πr could be used to calculate the area of a circle, using the built-in π constant, implicit multiplication and exponentiation indicated by a superscript. In TUTOR, the floating-point comparison x=y was defined as being true if x and y were approximately equal. This simplified life for mathematically naïve developers of instructional lessons, but it occasionally caused headaches for developers of numerically sophisticated code because it

456-427: A sequence of pattern matching commands, each of which introduces a (possibly empty) block of commands to be executed if that pattern matches. The two most common pattern matching commands were answer and wrong . These had identical pattern matching semantics except that answer judged a student response to be correct if it matched, while wrong judged a student response to be incorrect. The tag fields on

513-554: A shared unnamed common block, while nc1001 to nc1075 are private storage. The Tutor define command was very similar to the C #define preprocessor directive. This was the only way to associate mnemonic names with variables. It was up to the programmer to statically allocate memory and assign names to variables. Consider this example: This creates a set of definitions named mynames defining three floating point variables. Users were advised that " there should not be any v3's or v26's anywhere in your lesson except in

570-471: A single bit error is always within 1 Hamming distance of the original codes, and the code can be 1-error correcting , that is k=1 . Since the Hamming distance between "000" and "111" is 3, and those comprise the entire set of codewords in the code, the minimum Hamming distance is 3, which satisfies 2k+1 = 3 . Thus a code with minimum Hamming distance d between its codewords can detect at most d -1 errors and can correct ⌊( d -1)/2⌋ errors. The latter number

627-405: A single region of up to 1500 words of shared memory using the common command. Each lesson could have an unnamed temporary common block containing variables shared by all users of that lesson. Such blocks were created when a lesson came into use and deallocated when the lesson became inactive. In contrast, named common blocks were associated with a block of a lesson (a disk file). Shared memory

SECTION 10

#1733085864157

684-407: A word of the pattern, the Hamming distance between the two bit vectors was used as a measure of the degree of difference between the words. Bit vectors were typically 60 or 64 bits long, with fields for letter presence, letter pair presence, and the first letter. As a result, the number of one bits in the exclusive or of two such bit vectors approximated the extent of the phonetic difference between

741-412: Is a difference between the i th letter of a and the i th letter of c , then there must be a difference between the i th letter of a and i th letter of b , or between the i th letter of b and the i th letter of c . Hence the Hamming distance between a and c is not larger than the sum of the Hamming distances between a and b and between b and c . The Hamming distance between two words

798-549: Is a program that has pre-programmed elements for the development of interactive multimedia software titles. Authoring systems can be defined as software that allows its user to create multimedia applications for manipulating multimedia objects. In the development of educational software , an authoring system is a program that allows a non-programmer, usually an instructional designer or technologist, to easily create software with programming features. The programming features are built in but hidden behind buttons and other tools, so

855-411: Is also called the packing radius or the error-correcting capability of the code. The Hamming distance is named after Richard Hamming , who introduced the concept in his fundamental paper on Hamming codes , Error detecting and error correcting codes , in 1950. Hamming weight analysis of bits is used in several disciplines including information theory , coding theory , and cryptography . It

912-439: Is at least k +1. For example, consider a code consisting of two codewords "000" and "111". The Hamming distance between these two words is 3, and therefore it is k =2 error detecting. This means that if one bit is flipped or two bits are flipped, the error can be detected. If three bits are flipped, then "000" becomes "111" and the error cannot be detected. A code C is said to be k-error correcting if, for every word w in

969-444: Is erased so that the response to the new answer can be computed. The mechanism by which the display screen rolls back to its previous state varies from implementation to implementation. Early implementations operated by switching the terminal into erase mode and re-executing the entire case that had matched. Some later implementations buffered the output produced during judging so that this output could be erased. The join command

1026-422: Is known as the Hamming cube ; it is equivalent as a metric space to the set of distances between vertices in a hypercube graph . One can also view a binary string of length n as a vector in R n {\displaystyle \mathbb {R} ^{n}} by treating each symbol in the string as a real coordinate; with this embedding, the strings form the vertices of an n -dimensional hypercube , and

1083-504: Is named after the American mathematician Richard Hamming . A major application is in coding theory , more specifically to block codes , in which the equal-length strings are vectors over a finite field . The Hamming distance between two equal-length strings of symbols is the number of positions at which the corresponding symbols are different. The symbols may be letters, bits, or decimal digits, among other possibilities. For example,

1140-496: Is used in telecommunication to count the number of flipped bits in a fixed-length binary word as an estimate of error, and therefore is sometimes called the signal distance . For q -ary strings over an alphabet of size q  ≥ 2 the Hamming distance is applied in case of the q-ary symmetric channel , while the Lee distance is used for phase-shift keying or more generally channels susceptible to synchronization errors because

1197-467: The answer and wrong commands consisted of lists of optional, required and alternative words. consider this example: This would match answers such as "it is a right triangle" or "it's a triangular figure" or just "rt triangle". It would not match "sort of triangular" because the words "sort of" are not listed as ignored, and it would not match "triangle, right?" because the order is wrong. The pattern matching subsystem recognized spelling errors, so

SECTION 20

#1733085864157

1254-408: The define statement itself . Put all your definitions at the very beginning of the lesson where you will have ready reference to which variables you are using." Functions could be defined, with macro-substitution semantics, as in this illustration: Unlike C, the original scope rules of TUTOR were pure "definition before use" with no provisions for local definitions. Thus, the formal parameter

1311-467: The do command, conformed to the usual semantics associated with subroutine calls in other programming languages.) The PLATO IV student terminal had a 512 by 512 pixel plasma display panel , with hardware support for point plotting , line drawing, and text display. Each pixel on the PLATO IV terminal was either orange or black. The CDC PLATO V terminal used a monochrome black and white CRT to emulate

1368-526: The CDC 6600 family of computers. Some later implementations changed this to 64 bits. The private memory region of each process consisted of 150 words each, referred to as student variables; the values of these variables were persistent, following the individual user from session to session. These were addressed as n1 through n150 when used to hold integer values, or as v1 through v150 when used to hold floating point values. A TUTOR lesson could attach

1425-406: The zip() function merges two equal-length collections in pairs. The following C function will compute the Hamming distance of two integers (considered as binary values, that is, as sequences of bits). The running time of this procedure is proportional to the Hamming distance rather than to the number of bits in the inputs. It computes the bitwise exclusive or of the two inputs, and then finds

1482-513: The Hamming distance between two strings: Or, in a shorter expression: The function hamming_distance() , implemented in Python 3 , computes the Hamming distance between two strings (or other iterable objects) of equal length by creating a sequence of Boolean values indicating mismatches and matches between corresponding positions in the two inputs, then summing the sequence with True and False values, interpreted as one and zero, respectively. where

1539-428: The Hamming distance between: For a fixed length n , the Hamming distance is a metric on the set of the words of length n (also known as a Hamming space ), as it fulfills the conditions of non-negativity, symmetry, the Hamming distance of two words is 0 if and only if the two words are identical, and it satisfies the triangle inequality as well: Indeed, if we fix three words a , b and c , then whenever there

1596-493: The Hamming distance of the strings is equivalent to the Manhattan distance between the vertices. The minimum Hamming distance or minimum distance (usually denoted by d min ) is used to define some essential notions in coding theory , such as error detecting and error correcting codes . In particular, a code C is said to be k error detecting if, and only if, the minimum Hamming distance between any two of its codewords

1653-480: The Lee distance accounts for errors of ±1. If q = 2 {\displaystyle q=2} or q = 3 {\displaystyle q=3} both distances coincide because any pair of elements from Z / 2 Z {\textstyle \mathbb {Z} /2\mathbb {Z} } or Z / 3 Z {\textstyle \mathbb {Z} /3\mathbb {Z} } differ by 1, but

1710-452: The PLATO IV character set included control characters for subscript and superscript , and TUTOR used these for exponentiation. Consider this command The character set also included the conventional symbols for multiplication and division, × and ÷ , but in a more radical departure from the conventions established by FORTRAN, it allowed implicit multiplication, so the expressions (4+7)(3+6) and 3.4+5(2-3)/2 were valid, with

1767-475: The PLATO system by 1974 to automate this work. This could only deal with drawing commands with constant coordinates. The following example illustrates some of the text rendering tools of Tutor. Text rendered in size zero rotation zero used the built-in character rendering hardware of the PLATO terminal, while rendering with nonzero size and rotation was done with line segments and therefore significantly slower due to

TUTOR - Misplaced Pages Continue

1824-540: The Translation of Russian by Computer gives a snapshot of TUTOR from shortly before PLATO IV was operational. Core elements of the language were present, but commands were given in upper case, and instead of using a general mechanism, support for alternative character sets was through special command names such as WRUSS for "write using the Russian character set." Through the 1970s, the developers of TUTOR took advantage of

1881-463: The Tutor Language, presaging that of Python and adding a unique nonblank indent character to distinguish indenting from continuation lines. This is illustrated in the following example: (The assignment arrow in the calc statement is not rendered correctly in some browsers. It appears similar to <= but as one character. It had a dedicated key on the PLATO IV keyboard.) The same syntax

1938-439: The ability for the user to set the pace in which the content is delivered, and how learners engage with the content. Assessment refers to the ability to test learning outcomes within the system, usually in the form of tests, discussions, assignments, and other activities which can be evaluated. An authoring system usually includes an authoring language , a programming language built (or extended) with functionality for representing

1995-436: The array elements were to be treated as signed or unsigned were entirely under user control. Arbitrary text manipulation could be done by setting the byte size to the machine byte size, 6 bits on implementations using display code , 8 bits on some later ASCII and extended ASCII implementations. Note the lack of any specification of array dimensionality for segmented arrays. Authoring language An authoring system

2052-431: The author does not need to know how to program. Generally authoring systems provide many graphics, much interaction, and other tools educational software needs. The three main components of an authoring system are: content organization, control of content delivery, and type(s) of assessment. Content Organization allows the user to structure and sequence the instructional content and media. Control of content delivery refers to

2109-422: The body of the judging loop in the previous cycle is erased from the screen prior to the next cycle. Consider this example: In the event that the student inputs "square" or "a square", the answer is judged to be incorrect, and the text "A square has four sides." is output starting at line 15 column 1 on the screen. This output remains on the screen until the student begins to enter a new answer, at which point, it

2166-400: The corresponding symbols are different. In other words, it measures the minimum number of substitutions required to change one string into the other, or equivalently, the minimum number of errors that could have transformed one string into the other. In a more general context, the Hamming distance is one of several string metrics for measuring the edit distance between two sequences. It

2223-438: The corresponding words. All early presentations of the control structure of a TUTOR judging block were confusing. In modern terms, however, a judging block can be described as an iterative control structure that exits when the student input is judged correct. The body of this control structure consists of a series of cases , each introduced by a pattern matching command such as answer or wrong . All output produced by

2280-560: The distances are different for larger q {\displaystyle q} . The Hamming distance is also used in systematics as a measure of genetic distance. However, for comparing strings of different lengths, or strings where not just substitutions but also insertions or deletions have to be expected, a more sophisticated metric like the Levenshtein distance is more appropriate. The following function, written in Python 3, returns

2337-414: The draw command connects consecutive points with line segments, but by putting skip in the tag, the draw command could be made to conceptually lift its pen. The tags on the circle command give the radius and fine coordinates of the center. Additional tags could specify starting and ending angles for partial circles. Hand composing draw commands is difficult, so a picture editor was included in

TUTOR - Misplaced Pages Continue

2394-469: The entrance to a judging block This control structure is one of TUTOR's unique features. TUTOR contained a number of unique features. The following list is not intended as a substitute for a TUTOR manual, but merely highlights the most interesting, innovative, and sometimes confusing features of the language. A judging block in TUTOR is a control structure that begins with an arrow command and ends with

2451-485: The fact that the entire corpus of TUTOR programs were stored on-line on the same computer system. Whenever they felt a need to change the language, they ran conversion software over the corpus of TUTOR code to revise all existing code so that it conformed with the changes they had made. As a result, once new versions of TUTOR were developed, maintaining compatibility with the PLATO version could be very difficult. Control Data Corporation (CDC), by 1981, had largely expunged

2508-545: The name TUTOR from their PLATO documentation. They referred to the language itself as the PLATO Author Language . The phrase TUTOR file or even TUTOR lesson file survived, however, as the name of the type of file used to store text written in the PLATO Author Language. A TUTOR lesson consists of a sequence of units where each unit begins with the presentation of information and progress from one unit to

2565-437: The next arrow , endarrow or unit command. The arrow command also prompts for input, with the special arrow character (resembling "▷") displayed as a prompt at the indicated screen coordinates. In effect, a judging block can be thought of as a backtracking control structure where the student may make multiple attempts to answer a question until a correct answer allows forward progress. Each judging block consists of

2622-456: The next is contingent on correctly answering one or more questions. As with COBOL paragraphs, control may enter a TUTOR unit from the preceding unit and exit into the next, but units are also callable as subroutines using the do or join commands. Here is an example unit: Several things should be immediately apparent from this example. What may not be apparent is the control structure implicit in this unit. The arrow command marks

2679-484: The plasma panel. The built-in character set had 4 sets of 63 characters, each 8 by 16 pixels, half of these were fixed, half were programmable. The Tutor language provided complete support for this terminal. There were two coordinate systems The following example illustrates some of Tutor's drawing commands. Note the use of semicolons to separate successive coordinates on the draw command. This allows unambiguous use of comma-separated fine coordinates. Normally,

2736-432: The same 3-bit code consisting of the two codewords "000" and "111". The Hamming space consists of 8 words 000, 001, 010, 011, 100, 101, 110 and 111. The codeword "000" and the single bit error words "001","010","100" are all less than or equal to the Hamming distance of 1 to "000". Likewise, codeword "111" and its single bit error words "110","101" and "011" are all within 1 Hamming distance of the original "111". In this code,

2793-417: The speed of the communication link to the terminal. Aside from its unique answer judging mechanisms, TUTOR's original set of control structures was rather sparse. In the mid 1970s, this shortcoming was addressed by introducing if , endif blocks with optional elseif and else sections. The semantics of these control structures was routine, but the syntax inherited the mandatory indentation of

2850-586: The tutoring system. The functionality offered by the authoring language may be programming functionality for use by programmers or domain representation functionality for use by subject experts. There is overlap between authoring languages with domain representation functionality and domain-specific languages . An authoring language is a programming language used to create tutorials , computer-based training courseware , websites , CD-ROMs and other interactive computer programs . Authoring systems (packages) generally provide high-level visual tools that enable

2907-494: The underlying Hamming space H , there exists at most one codeword c (from C ) such that the Hamming distance between w and c is at most k . In other words, a code is k -errors correcting if the minimum Hamming distance between any two of its codewords is at least 2 k +1. This is also understood geometrically as any closed balls of radius k centered on distinct codewords being disjoint. These balls are also called Hamming spheres in this context. For example, consider

SECTION 50

#1733085864157

2964-434: The values 99 and 15.9, respectively (op cit). This feature was seen as essential. When students typed in a numeric answer to a question, they could use operators and variables and standard algebraic notation, and the program would use the TUTOR "compute" command to compile and run the formula and check that it was numerically equivalent (or within the floating point roundoff error) to the correct answer. The language included

3021-416: The words "triangel" or "triangl" would match the example pattern. The lesson author could use the specs command to set how pedantic the system was about spelling errors. The pattern matching algorithms used by various TUTOR implementations varied in detail, but typically, each word in the input text and each word in the pattern were converted to bit vectors . To see whether a word of student input matched

3078-409: Was a unique form of subroutine call. It was defined as being equivalent to textual substitution of the body of the joined unit in place of the join command itself. As such, a joined unit could contain part of a judging block. Thus, while the judging block is conceptually an iterator enclosing a series of cases , this block may be arbitrarily broken into subroutines. (An alternative subroutine call,

3135-444: Was addressed as nc1 through nc1500 (for integers) or vc1 through vc1500 (for floating point numbers). Where 150 student variables was insufficient, a lesson could use the storage command to create an additional private memory segment of up to 1000 words. This segment existed in swap space only, but it could be mapped to student variables or common variables. For example This example defines nc1 to nc1000 as

3192-431: Was possible that both x<y and x≥y could be true at the same time. As an authoring language, TUTOR began with only minimal memory resources and only the crudest tools for manipulating them. Each user process had a private data segment of 150 variables, and shared common blocks could be attached, allowing inter-user communication through shared memory. On the PLATO IV system, words were 60 bits, in keeping with

3249-404: Was used for loop , endloop blocks with semantics comparable to while loops in conventional programming languages. This is illustrated in the following example Note that the reloop and outloop commands are somewhat analogous to the continue and break statements of languages based on C , except that they must sit at the indenting level of the loop they modify, and they have

#156843