MultipageNavigation.xml

<mediawiki xmlns="http://www.mediawiki.org/xml/export-0.11/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mediawiki.org/xml/export-0.11/ http://www.mediawiki.org/xml/export-0.11.xsd" version="0.11" xml:lang="en">
  <siteinfo>
    <sitename>Coder Merlin</sitename>
    <dbname>wiki</dbname>
    <base>https://dev.codermerlin.com/wiki/index.php/Welcome_to_Coder_Merlin</base>
    <generator>MediaWiki 1.35.3</generator>
    <case>first-letter</case>
    <namespaces>
      <namespace key="-2" case="first-letter">Media</namespace>
      <namespace key="-1" case="first-letter">Special</namespace>
      <namespace key="0" case="first-letter" />
      <namespace key="1" case="first-letter">Talk</namespace>
      <namespace key="2" case="first-letter">User</namespace>
      <namespace key="3" case="first-letter">User talk</namespace>
      <namespace key="4" case="first-letter">Coder Merlin</namespace>
      <namespace key="5" case="first-letter">Coder Merlin talk</namespace>
      <namespace key="6" case="first-letter">File</namespace>
      <namespace key="7" case="first-letter">File talk</namespace>
      <namespace key="8" case="first-letter">MediaWiki</namespace>
      <namespace key="9" case="first-letter">MediaWiki talk</namespace>
      <namespace key="10" case="first-letter">Template</namespace>
      <namespace key="11" case="first-letter">Template talk</namespace>
      <namespace key="12" case="first-letter">Help</namespace>
      <namespace key="13" case="first-letter">Help talk</namespace>
      <namespace key="14" case="first-letter">Category</namespace>
      <namespace key="15" case="first-letter">Category talk</namespace>
      <namespace key="102" case="first-letter">Property</namespace>
      <namespace key="103" case="first-letter">Property talk</namespace>
      <namespace key="106" case="first-letter">Form</namespace>
      <namespace key="107" case="first-letter">Form talk</namespace>
      <namespace key="108" case="first-letter">Concept</namespace>
      <namespace key="109" case="first-letter">Concept talk</namespace>
      <namespace key="112" case="first-letter">smw/schema</namespace>
      <namespace key="113" case="first-letter">smw/schema talk</namespace>
      <namespace key="114" case="first-letter">Rule</namespace>
      <namespace key="115" case="first-letter">Rule talk</namespace>
      <namespace key="274" case="first-letter">Widget</namespace>
      <namespace key="275" case="first-letter">Widget talk</namespace>
      <namespace key="828" case="first-letter">Module</namespace>
      <namespace key="829" case="first-letter">Module talk</namespace>
      <namespace key="2300" case="first-letter">Gadget</namespace>
      <namespace key="2301" case="first-letter">Gadget talk</namespace>
      <namespace key="2302" case="case-sensitive">Gadget definition</namespace>
      <namespace key="2303" case="case-sensitive">Gadget definition talk</namespace>
      <namespace key="3000" case="first-letter">Invigilators</namespace>
      <namespace key="3001" case="first-letter">Invigilators talk</namespace>
      <namespace key="3002" case="first-letter">Guides</namespace>
      <namespace key="3003" case="first-letter">Guides talk</namespace>
    </namespaces>
  </siteinfo>
  <page>
    <title>Shell/Change Your Password</title>
    <ns>0</ns>
    <id>8554</id>
    <revision>
      <id>16895</id>
      <parentid>16237</parentid>
      <timestamp>2021-12-12T21:22:30Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>32224</id>
      </contributor>
      <origin>16895</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1169" sha1="9lz3hsdon8hluw9fn01uua2jzq8j4u5" xml:space="preserve">When you first log on to the server you'll have been assigned a password.  You should change this password to something that is easy for you to remember but difficult for others to guess (or derive).  (A good summary article of how to select strong passwords may be found [https://www.fpainc.com/blog/password-guidelines-from-nist here].)

The program that you'll use to change your password is '''passwd'''.  It will prompt you three times.  
* You'll first enter your current password
* then the new password that you want to use
* and then finally, to ensure that you're entering the new password correctly, you'll be prompted a second time for the new password.
{{Hint|
Remember that when you enter the password, what you type '''will not be echoed to the terminal'''.  You'll just need to pretend that the your keypresses are being received.
}}

Change your default password to a strong password:
{{ConsoleLines|john-williams@codermerlin:~$ passwd&lt;br/&gt;
Changing password for john-williams.&lt;br/&gt;
(current) UNIX password:&lt;br/&gt;
Enter new UNIX password:&lt;br/&gt;
Retype new UNIX password:&lt;br/&gt;
passwd: password updated successfully
}}


{{MerlinMultipageExperienceNavBar}}</text>
      <sha1>9lz3hsdon8hluw9fn01uua2jzq8j4u5</sha1>
    </revision>
  </page>
  <page>
    <title>Shell/Clear the Screen</title>
    <ns>0</ns>
    <id>8552</id>
    <revision>
      <id>16893</id>
      <parentid>16235</parentid>
      <timestamp>2021-12-12T21:22:17Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>32224</id>
      </contributor>
      <origin>16893</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="385" sha1="o0k95s32mhy9lgo5zdhgkt73ibvu6fj" xml:space="preserve">In some cases it’s useful to clear the screen. (For example, this might be useful if you sense your guide creeping up behind you when you were doing something that you weren’t supposed to be doing. 😁) We can do this with the clear command. Type '''clear''' and then press {{Key|RETURN}}.

{{ConsoleLine|john-williams@codermerlin:~$ |clear}}


{{MerlinMultipageExperienceNavBar}}</text>
      <sha1>o0k95s32mhy9lgo5zdhgkt73ibvu6fj</sha1>
    </revision>
  </page>
  <page>
    <title>Shell/Client and Server</title>
    <ns>0</ns>
    <id>8541</id>
    <revision>
      <id>16907</id>
      <parentid>16902</parentid>
      <timestamp>2021-12-12T21:41:14Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>32224</id>
      </contributor>
      <origin>16907</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1630" sha1="gheofqhcu5b3rg03onwq59gsb27v4n4" xml:space="preserve">[[File:Client-server-model.svg|thumb|link=|Client-server-model]] A '''client-server model''' is a means of distributing resources between the provider of a '''service''' and a consumer of that service, the client.  You're likely very familiar with this concept though less familiar with the name.  One common example of a service provided in this manner is email.  You, a '''user''', can open an email '''client''' (for example, an app on your iPhone or Outlook on a PC) which then connects to a remote '''server'''.  The ''server'' is responsible for providing several ''services'', including receiving mail on your behalf from other servers, transmitting email on your behalf to others, and storing your email for your later use.

{{Observe|Section 1|
# Name at least two other services that you personally use which are implemented using a Client/Server Model
}}

There are several advantages to this model:
* Users don't need to personally possess the hardware required to fulfill a particular service, only a means of connecting and communicating with a server which provides the service
* Users don't need to worry about installing and configuring the server hardware
* Users are able to access their data from anywhere in the world (as long as they have internet access)
* The state of a users data remains consistent, regardless of how and from where they access the server

Merlin is built upon this Client/Server Model, so you won't need any particular type of hardware or software, only a device capable of running a web-browser and a terminal emulator (available in Google Chrome).

{{MerlinMultipageExperienceNavBar}}</text>
      <sha1>gheofqhcu5b3rg03onwq59gsb27v4n4</sha1>
    </revision>
  </page>
  <page>
    <title>Shell/Deleting a File</title>
    <ns>0</ns>
    <id>8549</id>
    <revision>
      <id>16890</id>
      <parentid>16232</parentid>
      <timestamp>2021-12-12T21:20:33Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>32224</id>
      </contributor>
      <origin>16890</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="341" sha1="ieky6zcg82ieq2b0or29acjjfrt2bwk" xml:space="preserve">We can delete a file with the '''rm''' (remove) command. Let's try it:

{{ConsoleLine|john-williams@codermerlin:~$ |echo "Hello" &gt; hello.txt }}
{{ConsoleLine|john-williams@codermerlin:~$ |ls }}
{{ConsoleLine|john-williams@codermerlin:~$ |rm hello.txt }}
{{ConsoleLine|john-williams@codermerlin:~$ |ls }}


{{MerlinMultipageExperienceNavBar}}</text>
      <sha1>ieky6zcg82ieq2b0or29acjjfrt2bwk</sha1>
    </revision>
  </page>
  <page>
    <title>Shell/Directories Revisited</title>
    <ns>0</ns>
    <id>8551</id>
    <revision>
      <id>16892</id>
      <parentid>16234</parentid>
      <timestamp>2021-12-12T21:20:58Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>32224</id>
      </contributor>
      <origin>16892</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="2028" sha1="1ew4xmk4bhvubb4o7ezmmvjdyiclcrz" xml:space="preserve">There are useful shortcuts that you can use when specifying a path.
* "." (a single period or dot) refers to the ''current'' directory
* ".." (a double period, or two adjacent dots) refers to the ''parent'' directory, relative to wherever you happen to be in the path up to this point
Thus:
* To move to a ''parent'' directory, we can type {{Key|c}}{{Key|d}}{{Key|Space}}{{Key|.}}{{Key|.}}
* To move to a ''grandparent'' directory, we can type {{Key|c}}{{Key|d}}{{Key|Space}}{{Key|.}}{{Key|.}}{{Key|/}}{{Key|.}}{{Key|.}}

Assume we have a directory named 'parent' with two children, 'childA' and 'childB', and we are currently inside the 'childB' directory and want to enter the 'childA' directory.
* To move to a ''sibling'' directory, we can type {{Key|c}}{{Key|d}}{{Key|Space}}{{Key|.}}{{Key|.}}{{Key|/}}childA
=== View the Directory Hierarchy ===
Sometimes it’s helpful to obtain an overview of our directory hierarchy. We can do this with the '''tree''' command. Let's try:

{{ConsoleLine|john-williams@codermerlin:~$ |tree}}
{{ConsoleLines|
.&lt;br/&gt;
└─ Merlin&lt;br/&gt;
&amp;nbsp;&amp;nbsp;&amp;nbsp;├─&amp;nbsp;hello&lt;br/&gt;
&amp;nbsp;&amp;nbsp;&amp;nbsp;│&amp;nbsp;&amp;nbsp;├─ newFile.txt&lt;br/&gt;
&amp;nbsp;&amp;nbsp;&amp;nbsp;│&amp;nbsp;&amp;nbsp;└─ out.txt&lt;br/&gt;
&amp;nbsp;&amp;nbsp;&amp;nbsp;├─&amp;nbsp;hello2&lt;br/&gt;
&amp;nbsp;&amp;nbsp;&amp;nbsp;└─&amp;nbsp;hello3&lt;br/&gt;
}}

{{Observe|: Section 7|
# How does the '''ls''' command differ from the '''tree''' command?
# How do you choose to use one over the other?
}}

=== Remove a Directory ===
Let's remove the two directories that we won't be using anymore. We can do this with the '''rmdir''' command. Move to the Merlin directory and then remove the hello2 and hello3 directories. Then do a directory listing to see what’s left.

{{ConsoleLine|john-williams@codermerlin:~$ |cd Merlin}}
{{ConsoleLine|john-williams@codermerlin:~/Merlin$ |rmdir hello2}}
{{ConsoleLine|john-williams@codermerlin:~/Merlin$ |rmdir hello3}}
{{ConsoleLine|john-williams@codermerlin:~/Merlin$ |ls}}
{{ConsoleLine|hello|}}


{{MerlinMultipageExperienceNavBar}}</text>
      <sha1>1ew4xmk4bhvubb4o7ezmmvjdyiclcrz</sha1>
    </revision>
  </page>
  <page>
    <title>Shell/Directories</title>
    <ns>0</ns>
    <id>8545</id>
    <revision>
      <id>16886</id>
      <parentid>16228</parentid>
      <timestamp>2021-12-12T21:19:31Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>32224</id>
      </contributor>
      <origin>16886</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="5788" sha1="284kppoc6ax78zym6cwy9lfcmlj22ur" xml:space="preserve">=== Directory Hierarchy ===
[[File:LinuxFileHierarchy.png|thumb|link=|Linux File Hierarchy]]
All files are integrated into a single, hierarchical directory structure that appears as an inverted tree.  A '''directory''' provides a logical grouping of related files (and potentially other directories).  The top of this tree is called the '''root''' and is referred to by a slash (/). In the diagram, we see that the root contains five '''subdirectories''' (i.e., a directory below the parent directory):
bin, etc, home, lib, and tmp. The home directory contains two subdirectories, jack-williams and john-williams. Note that this differs from a Windows file structure as Unix integrates all files into a single directory structure rather than listing different physical storage devices. Thus, the file structure is '''logical''' rather than '''physical'''.  A '''path''' describes an ordered transition through one or more directories on the way to a destination (either a directory or a file).  As such, note that while both jack-williams and john-williams each have a subdirectory named "projects" these are ''different'' directories.  The path to the former is "/home/jack-williams/projects" while the path to the latter is "/home/john-williams/projects".  Paths which begin at the root (symbolized by the initial slash) are called '''absolute paths'''.  All other paths are '''relative paths'''.


{{Observe|: Section 2|
# It appears that both Jack Williams and John Williams can have a directory of the same name.  Do you think the ability to have two different users create a directory of the same name is important?  Why?
}}

=== Display the Working Directory (Where am I?) ===
The shell uses a concept known as your '''working directory''', which can be thought of as your current directory, i.e. where you are currently located in the file system. If you forget where you are, you can always use the command '''pwd''' to print the working directory. Try it now. Type “pwd” followed by &lt;RETURN&gt;. Note that you’ll need to press &lt;RETURN&gt; after any command before the shell will execute the command.

{{ConsoleLine|john-williams@codermerlin:~$ |pwd}}
{{ConsoleLine|/home/john-williams|}}

The command will print something similar to “/home/john-williams” and then present you with a new prompt and cursor to indicate that it’s ready and awaiting your input. This directory is your '''home directory''' and it has a special symbol, the '''tilde''' (~).

{{Observe|: Section 3|
# Why do you think the home directory has a special symbol to represent it?
}}

=== Create a New Directory ===
In order to keep our Merlin Missions organized, let’s place them all under a directory named “Merlin”. To make a new directory, we’ll use the command '''mkdir''' to which we’ll provide a single argument, the name of the directory that we want to create. Try it now. Type “mkdir Merlin” followed by &lt;RETURN&gt;.

{{ConsoleLine|john-williams@codermerlin:~$ |mkdir Merlin}}

=== Display the Contents of a Directory ===
How do we find out what’s contained in our current directory? We can use the '''ls''' (that’s a lowercase ‘L’ followed by a lowercase ’S’) command to list the directory contents. Try it now. Type “ls” followed by return.

{{ConsoleLine|john-williams@codermerlin:~$ |ls}}

The command will print the contents of the current directory (in this case our home directory) which will include the single directory, “Merlin”, that we created earlier.

=== Change to a New Directory ===
When we want to change our current directory we use the '''cd''' command followed by the name of the directory to which we want to change. Try it now. Type “cd Merlin”.

{{ConsoleLine|john-williams@codermerlin:~$ |cd Merlin}}
{{ConsoleLine|john-williams@codermerlin:~/Merlin$ |}}


{{Observe|: Section 4|
# Did the prompt change?  If so, how?  Why is this useful?
}}

Note that our prompt has now changed. Before the command was executed, the prompt contained a single tilde indicating that our home directory was our current directory. After executing the command our prompt now includes a tilde, followed by a slash, followed by “Merlin”. This indicates that we are in the directory named “Merlin” below our home directory. The slash is a '''delimiter''' separating the levels of our hierarchy.

Let’s try the ''pwd'' command again.

{{ConsoleLine|john-williams@codermerlin:~/Merlin$ |pwd}}

We can now see that from the root, we’re three levels down:&lt;br/&gt; 
/ (root)&lt;br/&gt;
home&lt;br/&gt;
john-williams&lt;br/&gt;
Merlin&lt;br/&gt;

The ''cd'' command has a useful shortcut. If we type the command without an argument, it will take us back to our home directory. It’s the equivalent of "cd ~". Let’s try it now:

{{ConsoleLine|john-williams@codermerlin:~/Merlin$ |cd}}
{{ConsoleLine|john-williams@codermerlin:~$ |}}

Now, move back to the Merlin directory by issuing the appropriate command.

=== Change to a New Directory Temporarily ===
When we want to change our current directory ''temporarily'' (meaning we want to return later to where we are now), we use the '''pushd''' command followed by the name of the directory to which we want to change. Try it now. Type “pushd Merlin”.

{{ConsoleLine|john-williams@codermerlin:~$ |pushd Merlin}}
{{ConsoleLine|john-williams@codermerlin:~/Merlin$ |}}

We can now perform any actions we'd like in this directory and when we're done, we can easily return from whence we came without needing to type in the original directory name.  The '''popd''' command will look up where we came (when we used '''pushd''') and return us to there.  Try it now.  Type '''popd'''.

{{ConsoleLine|john-williams@codermerlin:~/Merlin$ |popd}}
{{ConsoleLine|john-williams@codermerlin:~$ |}}


{{MerlinMultipageExperienceNavBar}}</text>
      <sha1>284kppoc6ax78zym6cwy9lfcmlj22ur</sha1>
    </revision>
  </page>
  <page>
    <title>Shell/Display a Manual</title>
    <ns>0</ns>
    <id>8555</id>
    <revision>
      <id>16896</id>
      <parentid>16238</parentid>
      <timestamp>2021-12-12T21:22:38Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>32224</id>
      </contributor>
      <origin>16896</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="684" sha1="h9jsiymsrv2mqabke3ms8zaxwv4t1c1" xml:space="preserve">Finally, let's try out one more very helpful command. If we want to learn more about a command we can read its ''manual''. We do this with the command '''man'''. As an example, look at the man page for the emacs command. Type '''man emacs'''. 

{{ConsoleLine|john-williams@codermerlin:~/Merlin$ |man emacs}}

The screen will be filled with information about the emacs command. While a man page is displayed we can use the following keys to navigate:

* Typing {{Key|f}} will move us forward one page in the manual
* Typing {{Key|b}} will move us backward one page in the manual
* Typing {{Key|q}} will quit (exit the manual)

Exit the manual now.


{{MerlinMultipageExperienceNavBar}}</text>
      <sha1>h9jsiymsrv2mqabke3ms8zaxwv4t1c1</sha1>
    </revision>
  </page>
  <page>
    <title>Shell/Exiting the Shell</title>
    <ns>0</ns>
    <id>8556</id>
    <revision>
      <id>16897</id>
      <parentid>16239</parentid>
      <timestamp>2021-12-12T21:22:54Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>32224</id>
      </contributor>
      <origin>16897</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="479" sha1="0l09uqwjvyvs5t0pavinj5xgp8j9iwa" xml:space="preserve">In general, there's no need to exit the shell.  It's almost always sufficient to close your terminal emulator.  An advantage to this approach is that the next time you connect to the server you'll be in exactly the same place where you left off.  However, on rare occasions the terminal emulator can become "confused" and display characters in odd places.  In such a case, there's still no need to exit; instead, use the '''reset''' command.


{{MerlinMultipageExperienceNavBar}}</text>
      <sha1>0l09uqwjvyvs5t0pavinj5xgp8j9iwa</sha1>
    </revision>
  </page>
  <page>
    <title>Shell/Files</title>
    <ns>0</ns>
    <id>8548</id>
    <revision>
      <id>16889</id>
      <parentid>16231</parentid>
      <timestamp>2021-12-12T21:20:26Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>32224</id>
      </contributor>
      <origin>16889</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="3336" sha1="3vvfe756jwhet85jhxffwcv6fn53zqq" xml:space="preserve">=== Echo to the Screen ===
The echo command echoes the argument to the output. Let’s try it. Type: '''echo "Hello, World!"''' The echo command dutifully echoes the argument to the screen. Try it now:

{{ConsoleLine|john-williams@codermerlin:~/Merlin/hello$ |echo "Hello, World!"}}
{{ConsoleLine|Hello, World!|}}

=== Create an Empty File ===
The touch command creates a new, empty file, if such a file does not already exist. If such a file does already exist, the access and modification times will be set to the current time.  Try it now:

{{ConsoleLine|john-williams@codermerlin:~/Merlin/hello$ |touch newFile.txt}}
{{ConsoleLine|john-williams@codermerlin:~/Merlin/hello$ |ls}}
{{ConsoleLine|newFile.txt|}}

We'll see the '''cat''' command more below, but for now it's enough to understand that it will display the contents of a file.  Because this is a new, empty file, nothing will be displayed.  Try it now:
{{ConsoleLine|john-williams@codermerlin:~/Merlin/hello$ |cat newFile.txt}}
{{ConsoleLine|john-williams@codermerlin:~/Merlin/hello$ |}}

=== Redirection ===
Remember that we said that almost everything in Unix is either a file or a process and that the screen could be considered as a file. We can '''redirect''' the output from echo to another file, one that we'll store in the file system. We do this with the &gt; (greater-than) symbol. Normally, commands will send their output to a device called '''stdout'''. This is what the echo command did when we used it earlier. In our case, stdout is printed to our terminal. Let’s try to redirect our output to a file. Type: '''echo "Hello, World!" &gt; out.txt''':

{{ConsoleLine|john-williams@codermerlin:~/Merlin/hello$ |echo "Hello, World!" &gt; out.txt}}


{{Observe|: Section 6|
# Was "Hello, World!" printed to the screen as before?  If not, why not?  What do you think happened to the text?
}}



No output was displayed; we just received a new prompt. Let’s use the '''ls''' command to take a look:

{{ConsoleLine|john-williams@codermerlin:~/Merlin/hello$ |ls}}
{{ConsoleLine|newFile.txt out.txt|}}

We can see that the directory contains a single file, "out.txt" which was created by the echo command. How can we see what's contained within this file?

=== Quickly View File Contents ===
To quickly view the contents of a file we can use the '''cat''' command.  The cat command '''concatenates''' files together and then sends the output to stdout. (Remember that in our case this is the screen.) Let’s try it. Type "cat out.txt".

{{ConsoleLine|john-williams@codermerlin:~/Merlin/hello$ |cat out.txt}}
{{ConsoleLine|Hello, World!|}}

=== Append a Small Amount of Text to an Existing File ===
If we already have an existing file with some text we can '''append''' (add text to the end) of this file by using echo and redirection as before but with ''two'' "greater-than" symbols adjacent to one another.  Try it now.  Type: echo "Hello, again!" &gt;&gt; out.txt

{{ConsoleLine|john-williams@codermerlin:~/Merlin/hello$ |echo "Hello, again!" &gt;&gt; out.txt}}
{{ConsoleLine|john-williams@codermerlin:~/Merlin/hello$ |}}

Let’s move back up to our home directory. Remember that we can do this by typing "cd" without any arguments.

{{ConsoleLine|john-williams@codermerlin:~/Merlin/hello$ |cd}}
{{ConsoleLine|john-williams@codermerlin:~$ |}}


{{MerlinMultipageExperienceNavBar}}</text>
      <sha1>3vvfe756jwhet85jhxffwcv6fn53zqq</sha1>
    </revision>
  </page>
  <page>
    <title>Shell/First Connection</title>
    <ns>0</ns>
    <id>8542</id>
    <revision>
      <id>16903</id>
      <parentid>16225</parentid>
      <timestamp>2021-12-12T21:35:53Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>32224</id>
      </contributor>
      <origin>16903</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1634" sha1="q6qid6hch3ccn3dncwl3u07nzjv6qb2" xml:space="preserve">Coder Merlin is a cloud-based server where we’ll be doing most of our exercises.  To access Merlin, you’ll need a '''secure shell client'''.  

If you’re using a Mac or a Linux based device you’ll probably have a built-in client that you can access from the terminal.  

If you’re using a Windows-based device, you can access a terminal by installing Google Chrome, and then within Google Chrome typing “Secure Shell Extension” and then installing the extension.

Either way, you’ll need a connection string to access the server.  The connection string will begin with your first name and last name separated by a hyphen, for example: '''john-williams'''.  The rest of the connection string will be '''@ssh.codermerlin.com'''

For John Williams, the entire connection string would be:
{{ConsoleLine||john-williams@ssh.codermerlin.com}}

After you’re connected, you’ll be prompted to enter your password.  After a successful logon, you'll land in the "shell".


{{Hint|
You won't see your password being echoed to the terminal as you type it.  This occurs to keep others from easily seeing your password.  Just believe that your keypresses are being received correctly.}}


{{Caution|
The correct connection string, like many identifiers that you'll encounter in computer science, must be entered exactly.  There is no tolerance for any variance.  As such, pay close attention to the requirements.  If you make a mistake, you may be locked out of the server for a period of time.  If this happens, verify the connection string and your password, wait a while, then try again.}}


{{MerlinMultipageExperienceNavBar}}</text>
      <sha1>q6qid6hch3ccn3dncwl3u07nzjv6qb2</sha1>
    </revision>
  </page>
  <page>
    <title>Shell/Jobs</title>
    <ns>0</ns>
    <id>8553</id>
    <revision>
      <id>16894</id>
      <parentid>16236</parentid>
      <timestamp>2021-12-12T21:22:23Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>32224</id>
      </contributor>
      <origin>16894</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="5030" sha1="hol22wijzbzty10jyb66evqmbq58x0f" xml:space="preserve">A '''program''' is an executable file which contains a series of instructions which can be executed by the computer.  A '''process''' is a ''program'' which is ''being executed'' on the computer.  The shell manages processes using the concept of a '''job'''.  You can obtain a list of jobs and suspend and resume jobs.  This functionality enables you to maximize your use of time rather than wait for the prompt to return as the shell waits for the execution of a job to complete.

=== Identifying Jobs ===
The shell provides several different ways to identify a job:
* &lt;code&gt;%''n''&lt;/code&gt; - The specific job number is preceded by a percentage sign
* &lt;code&gt;%+&lt;/code&gt; - A shortcut to specify the current job
* &lt;code&gt;%-&lt;/code&gt; - A shortcut to specify the previous job

=== Listing Jobs ===
Jobs may be listed with the '''jobs''' command.  Let's try an example by executing a few long-running jobs.  The '''sleep''' command simply waits before returning.  Let's try it:
{{ConsoleLine|john-williams@codermerlin:~$|sleep 3}}

Let's try it again:
{{ConsoleLine|john-williams@codermerlin:~$|sleep 5}}


{{Observe|: Section 8|
# What do you think the argument to sleep specifies?
# Are you able to prove your hypothesis?  How?
}}


These same jobs can be executed in the background (more on this below) simply by specifying an ampersand (&amp;) after the command.  


Let's try it:
{{ConsoleLine|john-williams@codermerlin:~$|sleep 60 &amp;}}


{{Observe|: Section 9|
# How is the behavior different from what you expected?
# What do you think it means to run a job in the background?
# What do you think the number displayed in brackets specifies?
}}


Let's run several jobs in the background and then view a list of our jobs:
{{ConsoleLine|john-williams@codermerlin:~$|sleep 40 &amp;}}
{{ConsoleLine|john-williams@codermerlin:~$|sleep 30 &amp;}}
{{ConsoleLine|john-williams@codermerlin:~$|sleep 20 &amp;}}

Now, let's use the '''jobs''' command:
{{ConsoleLine|john-williams@codermerlin:~$|jobs}}

Repeatedly execute the '''jobs''' command.

{{Observe|: Section 10|
# What do you observe as you execute the '''jobs''' command?
# How do you explain your observations?
}}

=== Terminating a Job ===
While a job is executing, we may decide that we want to terminate it.  Perhaps it is taking too long or we began executing it with the wrong arguments.  We can often terminate the job with a special key sequence, {{SpecialKey|CONTROL|C}}. 

Let's try an example.  We'll execute the '''cat''' command without any arguments, which will cause it to wait for something to be entered on the console.  

{{ConsoleLine|jane-williams@codermerlin:~$|cat}}

The process is now waiting.  If we realize that we made a mistake (perhaps we wanted to print the contents of a file and forgot to specify the file's name) we can terminate the job.  Try it now by pressing {{SpecialKey|CONTROL|C}}.

=== Foreground Jobs ===
Generally, when we execute a program we run it in the '''foreground'''.  This means that our shell will execute the process and we won't be able to execute the next command until the currently running foreground process exits.  This is ideal for short, interactive programs.  Whenever we execute a program, running that program in the foreground is the default.  For example, the '''find''' command can search for all files and directories within our home directory.  Let's try it:

{{ConsoleLine|jane-williams@codermerlin:~/Merlin$|cd}}
{{ConsoleLine|jane-williams@codermerlin:~$|find}}

We'll likely see a long list of files and directories quickly scroll by.  But what if we want to generate a list of all of the files and directories on the entire server?  This can take a while. Let's try it, just for fun:

{{ConsoleLine|jane-williams@codermerlin:~/$|find /}}

Eventually we'll encounter a permissions error and the process will halt.  But if you don't have the patience to wait, remember that you can use the key sequence {{SpecialKey|CONTROL|C}} to terminate the process immediately.  Alternatively, we can use the key sequence {{SpecialKey|CONTROL|Z}} to ''suspend'' the process.  When we suspend a process we can resume it in the foreground with '''fg''' followed by the job number.

=== Background Jobs ===
When we have a complex process that will take a long time to execute we don't want to be blocked from executing other commands while we wait for the long-running process to finish.  In these cases, we can execute the long-running process in the '''background'''.  Running the program in the background means that the process will continue to execute but we'll be able to enter new commands immediately.  We saw an example of this above where we executed multiple '''sleep''' jobs simultaneously.  We were able to do so because the shell was ready to accept new input ''before'' the previous job completed.

We can begin a job in the background by using an ampersand (&amp;) after typing the command.  When we suspend a process we can resume it in the background with '''bg''' followed by the job number.


{{MerlinMultipageExperienceNavBar}}</text>
      <sha1>hol22wijzbzty10jyb66evqmbq58x0f</sha1>
    </revision>
  </page>
  <page>
    <title>Shell/Recall Previous Commands</title>
    <ns>0</ns>
    <id>8547</id>
    <revision>
      <id>16888</id>
      <parentid>16230</parentid>
      <timestamp>2021-12-12T21:20:22Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>32224</id>
      </contributor>
      <origin>16888</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="608" sha1="pgioyzyjwr6ab6uy23hecp7vmz4fxbe" xml:space="preserve">Sometimes it's expedient to quickly recall a previous command without the need to re-type it.  The most common means of accomplishing this is to use the up-arrow.  Let's try it:
{{ConsoleLine|john-williams@codermerlin:~$ |ls}}

Now, let's repeat the command, but rather than type '''ls''' again, try typing the up-arrow:
{{ConsoleLine|john-williams@codermerlin:~$ |{{Key|↑}}}}

Try pressing the {{Key|↑}} and {{Key|↓}} several times.

{{Observe|: Section 5|
# What happens each time you press the {{Key|↑}}?
# What happens each time you press the {{Key|↓}}?
}}


{{MerlinMultipageExperienceNavBar}}</text>
      <sha1>pgioyzyjwr6ab6uy23hecp7vmz4fxbe</sha1>
    </revision>
  </page>
  <page>
    <title>Shell/Renaming a File</title>
    <ns>0</ns>
    <id>8550</id>
    <revision>
      <id>16891</id>
      <parentid>16233</parentid>
      <timestamp>2021-12-12T21:20:50Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>32224</id>
      </contributor>
      <origin>16891</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="350" sha1="k6512kqoudu7g3x8lkks176lnjl9pu6" xml:space="preserve">We can rename a file with the '''mv''' (move) command. Let's try it:

{{ConsoleLine|john-williams@codermerlin:~$ |echo "Hello" &gt; hello.txt }}
{{ConsoleLine|john-williams@codermerlin:~$ |ls }}
{{ConsoleLine|john-williams@codermerlin:~$ |mv hello.txt goodbye.txt}}
{{ConsoleLine|john-williams@codermerlin:~$ |ls }}


{{MerlinMultipageExperienceNavBar}}</text>
      <sha1>k6512kqoudu7g3x8lkks176lnjl9pu6</sha1>
    </revision>
  </page>
  <page>
    <title>Shell/Tab Completion</title>
    <ns>0</ns>
    <id>8546</id>
    <revision>
      <id>16887</id>
      <parentid>16229</parentid>
      <timestamp>2021-12-12T21:20:17Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>32224</id>
      </contributor>
      <origin>16887</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="2040" sha1="525pludhvvz4eji8j24xach52jdj0kr" xml:space="preserve">Very often, the shell can help us to complete file and directory names when we begin to type the name of a file (or directory) and then type {{Key|TAB}}. Try it now. Type "cd M" and then press {{Key|TAB}}. The shell will complete the rest of the name by appending "erlin" to what you’ve already typed. Then press {{Key|ENTER}}. Because the completion is not ambiguous (i.e. there is only one solution) the shell will complete the name. If there were multiple possibilities, the shell would complete as much as possible and then beep. At this point, we could press {{Key|TAB}} twice in succession to see the possible completions. Let’s try this. Within the Merlin directory, create three new directories: hello, hello2, and hello3:

{{ConsoleLine|john-williams@codermerlin:~/Merlin$ |mkdir hello}}
{{ConsoleLine|john-williams@codermerlin:~/Merlin$ |mkdir hello2}}
{{ConsoleLine|john-williams@codermerlin:~/Merlin$ |mkdir hello3}}

Then, type “cd h”:

{{ConsoleLine|john-williams@codermerlin:~/Merlin$ |cd h}}

Now, press {{Key|TAB}}.  The shell will complete as much of the name as possible and then beep. (Depending on your terminal you may not hear the beep or you may see a flash.)

{{ConsoleLine|john-williams@codermerlin:~/Merlin$ |cd hello}}

Now press {{Key|TAB}} twice in succession. The shell will display matching possibilities and then provide a new prompt followed by the previous entry:

{{ConsoleLine|hello/ hello2/ hello3/|}}
{{ConsoleLine|john-williams@codermerlin:~/Merlin$ |cd hello}}

You now have the option of pressing {{Key|ENTER}} to accept "hello" or adding some more characters (in this case “2” to form “hello2” or “3” to form “hello3”) and then pressing {{Key|ENTER}} to execute the command as-is or {{Key|TAB}} to search for additional completions. In our case, let’s press {{Key|ENTER}} to descend into the "hello" directory:

{{ConsoleLine|john-williams@codermerlin:~/Merlin$ |cd hello}}
{{ConsoleLine|john-williams@codermerlin:~/Merlin/hello$ |}}


{{MerlinMultipageExperienceNavBar}}</text>
      <sha1>525pludhvvz4eji8j24xach52jdj0kr</sha1>
    </revision>
  </page>
  <page>
    <title>Shell/Terminating a Partial Command</title>
    <ns>0</ns>
    <id>8544</id>
    <revision>
      <id>16885</id>
      <parentid>16227</parentid>
      <timestamp>2021-12-12T21:19:22Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>32224</id>
      </contributor>
      <origin>16885</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="830" sha1="n3y42h9u7f03pdwdoilxxt32o40pqg4" xml:space="preserve">If you begin a command in error or change your mind about issuing a command, you can use the {{SpecialKey|CONTROL|C}} key sequence to cancel what you've typed so far and continue with a new command prompt.

Try it now:
{{ConsoleLine|john-williams@codermerlin:~$ |echo iThoughtIKnewWhatIWasDoingBut {{SpecialKey|CONTROL|C}} }}


{{Hint|
If you began issuing a command but need to do something else in the shell before actually issuing it, an alternative to the above is to temporarily store what you've typed so far, do something else, then return to the original command.  You can do that with:
{{{Bar}}  class{{Equal}}"wikitable"
    {{Bar}}{{SpecialKey|CONTROL|U}} 
    {{Bar}} Cut backwards
{{Bar}}-
    {{Bar}}{{SpecialKey|CONTROL|Y}} 
    {{Bar}} Yank the original text back
{{Bar}}}

}}


{{MerlinMultipageExperienceNavBar}}</text>
      <sha1>n3y42h9u7f03pdwdoilxxt32o40pqg4</sha1>
    </revision>
  </page>
  <page>
    <title>Shell/The Shell</title>
    <ns>0</ns>
    <id>8543</id>
    <revision>
      <id>16884</id>
      <parentid>16323</parentid>
      <timestamp>2021-12-12T21:19:15Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>32224</id>
      </contributor>
      <origin>16884</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1759" sha1="c2ez6zc96y1uuwab7acikr52lwphzzd" xml:space="preserve">A shell is a user interface which provides access to an operating system’s services. There are two basic types of shells: a “command-line interface” (CLI) and a “graphical user interface” (GUI). You are likely familiar with common GUI’s from Microsoft Windows and perhaps Apple’s macOS. This document will focus on a CLI known as '''bash''', a shell for the Unix operating system by Brian Fox. '''Bash''' is an acronym for Bourne-again shell, named for the Bourne shell that it replaces.
Login to the Merlin Server as discussed previously. After some introductory text, you’ll see a '''prompt''' (letting you know that the server is ready and waiting for your input) which will look something like this:
{{ConsoleLine|john-williams@codermerlin:~$|}}
You’ll see your login name, an at (@) sign, the name of the server (“codermerlin”), a colon (:), a tilde (~), and a $. This will be followed by a flashing block called a '''cursor'''. The cursor indicates where new characters will appear as you type. The cursor will continue to flash patiently as it awaits input. We’ll get back to the meaning of the tilde soon.

We'll be using a server running Linux, a Unix-like operating system.  Almost everything in Unix is either a file or a process. A '''file''' is either a destination or source for a stream of data. A '''process''' is a program that is being executed by the operating system. While printers and screens are considered to be “files” in Unix, a more general way of thinking of files is a collection of data that can be referred to by name. Files can be created by users directly (for example, via a text editor) or indirectly, such as the result of running a program like a compiler.


{{MerlinMultipageExperienceNavBar}}</text>
      <sha1>c2ez6zc96y1uuwab7acikr52lwphzzd</sha1>
    </revision>
  </page>
  <page>
    <title>Shell</title>
    <ns>0</ns>
    <id>1046</id>
    <revision>
      <id>16911</id>
      <parentid>16910</parentid>
      <timestamp>2021-12-12T21:53:29Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>32224</id>
      </contributor>
      <origin>16911</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="6071" sha1="g0yce168ky4rop8ip43f3hqdlvl0uqg" xml:space="preserve">== Curriculum ==
{{MerlinCurriculumData|{{ROOTPAGENAME}}}}
== Experience ==
{{MerlinMultipageExperienceSubpages
|Pages=Client and Server;First Connection;The Shell;Terminating a Partial Command;Directories;Tab Completion;Recall Previous Commands;Files;Deleting a File;Renaming a File;Directories Revisited;Clear the Screen;Jobs;Change Your Password;Display a Manual;Exiting the Shell
}}

{{SeeAlso|
[[Category:Linux||Bash||SSH client||SFTP client]]|
* https://en.wikipedia.org/wiki/Operating_system
* https://en.wikipedia.org/wiki/System_software
* https://en.wikipedia.org/wiki/Computer_hardware 
* https://en.wikipedia.org/wiki/Application_software
* https://en.wikipedia.org/wiki/Shell_(computing)
* https://en.wikibooks.org/wiki/A_Quick_Introduction_to_Unix/Files_and_Processes
* https://en.wikibooks.org/wiki/A_Quick_Introduction_to_Unix/Directory_Structure
* https://unix.stackexchange.com/questions/89114/what-does-the-jargon-filesystem-mean
* http://www.aboutlinux.info/2005/05/job-control-in-linux.html
* https://www.cis.gvsu.edu/linux-tutorial-job-control/
* https://unix.stackexchange.com/questions/4214/what-is-the-difference-between-a-job-and-a-process
}}

== Key Concepts ==
{{KeyConcepts|
* A '''client-server model''' is a means of distributing resources between the provider of a service and a consumer of that service, the client.  The advantages of this model include:
** Users don't need to personally possess the hardware and software required to implement the service
** Users don't need to worry about installation and configuration
** Users are able to access their data from anywhere in the world 
** The state of a users data remains consistent, regardless of how and from where they access the server
* A '''shell''' is a user interface which provides access to an operating system’s services. There are two basic types of shells: 
** A '''command-line interface''' (CLI)
** A '''graphical user interface''' (GUI)
* A '''prompt''' lets you know that the server is ready and waiting for your input
* A '''cursor''' is a flashing block which indicates where new characters will appear as you type
* A '''file''' is either a destination or source for a stream of data
* A '''process''' is a program that is being executed by the operating system
* All files are integrated into a single, hierarchical structure called a '''directory'''  
** A directory provides a ''logical grouping'' of related files (and potentially other directories)
** The top of this tree is called the '''root''' and is referred to by a slash (/)
** A '''subdirectory''' is a directory contained within another directory, called the '''parent directory'''
** On Unix systems, the file structure is ''logical'' rather than ''physical''
** A '''path''' describes an ordered transition through one or more directories on the way to a destination (either a directory or a file)
*** Paths which begin at the root (symbolized by the initial slash) are called '''absolute paths'''
*** All other paths are '''relative paths'''
** Your '''home directory''' is indicated by a special symbol, the ''tilde'' (~)
** Your '''working directory''' can be thought of as your current directory
** The command '''pwd''' prints the working directory
** The command '''mkdir''' creates a new directory
** The command '''ls''' lists the contents of a directory
** The command '''cd''' changes your working directory
** The command '''pushd''' changes our working directory temporarily 
** The command '''popd''' returns us to our previous directory after executing pushd
** The command '''tree''' displays a directory hierarchy
** The command '''rmdir''' removes (deletes) a directory
* The '''echo''' command echoes the argument to the output
* The '''touch''' command creates a new, empty file, if such a file does not already exist. If such a file does already exist, the access and modification times will be set to the current time.
* The greater-than symbol (&gt;) can be used to ''redirect'' output to a file
* Two greater-than symbols (&gt;&gt;) can be used to ''append'' output to a file
* The '''cat''' command allows us to quickly view the contents of one or more files
* The '''rm''' command is used to remove (delete) a file
* The '''mv''' command is used to either move or rename a file
* The '''clear''' command clears the screen
* A '''program''' is an executable file which contains a series of instructions which can be executed by the computer
* A '''process''' is a program which is ''being executed'' on the computer
* The shell manages processes using '''jobs'''
* The '''jobs''' command will list the current jobs associated with your shell
** A job can be terminated by using the key sequence {{SpecialKey|CONTROL|C}}
** A job can be suspended by using the key sequence {{SpecialKey|CONTROL|Z}}
** A job can be resumed in the foreground with '''fg'''
** A job can be resumed in the background with '''bg'''
* The '''man''' command displays the contents of a manual
* The '''reset''' command resets your terminal
}}

== Exercises ==
{{Exercises|
Using pencil and paper, answer all questions in this experience.
&lt;hr/&gt;
''After completing W1005:''
* {{JournalAssignment|J1002}}
&lt;hr/&gt;
''After completing W1008:''
* {{MMMAssignment|M1002-10}}
* {{MMMAssignment|M1002-31}}
}}
{{Experience
|experienceID=W1002
|experienceUnit=Lab basics
|knowledgeAndSkills=§10.121
|topicAreas=SSH clients;Linux;Bash
|classroomTime=1 hour
|studyTime=3 hours
|acquiredKnowledge=differentiate between a CLI and GUI;
understand files, directories, and their organizational hierarchy;
understand of the client-server model;
understand processes;
understand the purpose of a prompt and cursor
|acquiredSkill=ability to append text to an existing file;
ability to create new text files;
ability to create new, empty files;
ability to delete files and directories;
ability to move and rename files and directories;
ability to successfully determine location in the file hierarchy;
ability to successfully navigate the file hierarchy;
ability to suspend and resume processes;
ability to terminate processes;
}}</text>
      <sha1>g0yce168ky4rop8ip43f3hqdlvl0uqg</sha1>
    </revision>
  </page>
    <page>
    <title>Property:Course page</title>
    <ns>102</ns>
    <id>8597</id>
    <revision>
      <id>16636</id>
      <timestamp>2021-12-06T17:27:11Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>30524</id>
      </contributor>
      <comment>Created a property of type Page</comment>
      <origin>16636</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="46" sha1="jk9aupditbfg4coza27xh6berm5n0sp" xml:space="preserve">This is a property of type [[Has type::Page]].</text>
      <sha1>jk9aupditbfg4coza27xh6berm5n0sp</sha1>
    </revision>
  </page>
  <page>
    <title>Property:Course page number</title>
    <ns>102</ns>
    <id>8596</id>
    <revision>
      <id>16635</id>
      <timestamp>2021-12-06T17:26:55Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>30524</id>
      </contributor>
      <comment>Created a property of type Number</comment>
      <origin>16635</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="48" sha1="id8gn0keu2a1u84x5rhv7b3oxwkgls6" xml:space="preserve">This is a property of type [[Has type::Number]].</text>
      <sha1>id8gn0keu2a1u84x5rhv7b3oxwkgls6</sha1>
    </revision>
  </page>
  <page>
    <title>Template:MerlinMultipageExperienceSubpages</title>
    <ns>10</ns>
    <id>8599</id>
    <revision>
      <id>16705</id>
      <parentid>16704</parentid>
      <timestamp>2021-12-06T22:15:32Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>30524</id>
      </contributor>
      <origin>16705</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1575" sha1="59015dsu38f2zm4es4gxyuur51ymms4" xml:space="preserve">&lt;includeonly&gt;&lt;div class="d-none"&gt;
{{#set:Sequenced subpages={{{Pages|}}}}}
{{#arraydefine: slides
  |{{{Pages|}}}
  |;
}}
{{#arrayprint: slides
  |
  |@
  |{{#subobject:@
     |Course page={{FULLPAGENAME}}/@
     |Course page number={{#expr:0{{#arraysearch:slides|@}}+1}}
   }}
}}
&lt;/div&gt;
&lt;div class="plainlinks mt-4 {{#ifeq: {{#titleparts:{{FULLPAGENAME}}||-1}}|All|d-none}}"&gt;&lt;!--

--&gt;[[{{FULLPAGENAME}}/{{#arrayindex: slides|0}}|&lt;span class="btn btn-lg btn-dark text-white"&gt;{{{1|Start}}}&lt;/span&gt;]] &lt;!--

--&gt;{{#if: {{#ask: [[{{FULLPAGENAME}}/All]][[Modification date::+]] }}
     |[[{{FULLPAGENAME}}/All|&lt;span class="btn btn-lg btn-link"&gt;One page&lt;/span&gt;]]
     |[{{fullurl:{{FULLPAGENAME}}/All|action=edit&amp;preload=Template:MerlinMultipageExperienceAllPreload}} &lt;span class="btn btn-lg btn-link"&gt;One page&lt;/span&gt;]
   }}
&lt;/div&gt;__NOTOC__
&lt;/includeonly&gt;
&lt;noinclude&gt;
Converts a page into a cover page of an education course.

;Usage
&lt;pre class="linenum"&gt;
{{MerlinMultipageExperienceSubpages
|Pages = # the ordered list of subpages delimited by a semicolon
|        # the first unnamed parameter is used as the start button label (default = Start)
}}&lt;/pre&gt;
;Example
&lt;pre class="linenum"&gt;
{{MerlinMultipageExperienceSubpages
|Pages=Sample Course/Student Welcome;
Merlin History;
Merlin Video;
Merlin
|Start training
}}&lt;/pre&gt;
; Related stuff
:Properties
:* [[Property:Course page]]
:* [[Property:Course page number]]
:Templates
:* [[Template:MerlinMultipageExperienceAll]]
:* [[Template:MerlinMultipageExperienceAllPreload]]
:* [[Template:MerlinMultipageExperienceNavBar]]
&lt;/noinclude&gt;</text>
      <sha1>59015dsu38f2zm4es4gxyuur51ymms4</sha1>
    </revision>
  </page>
  <page>
    <title>Template:MerlinMultipageExperienceAllPreload</title>
    <ns>10</ns>
    <id>8600</id>
    <revision>
      <id>16695</id>
      <parentid>16694</parentid>
      <timestamp>2021-12-06T22:08:22Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>30524</id>
      </contributor>
      <minor/>
      <comment>Anton-krom moved page [[Template:MerlinAllTopics]] to [[Template:MerlinMultipageExperienceAllPreload]] without leaving a redirect</comment>
      <origin>16694</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="32" sha1="1rw5gz42ko5efab13c643igjhetcd58" xml:space="preserve">{{MerlinMultipageExperienceAll}}</text>
      <sha1>1rw5gz42ko5efab13c643igjhetcd58</sha1>
    </revision>
  </page>
  <page>
    <title>Template:MerlinMultipageExperienceAll</title>
    <ns>10</ns>
    <id>8539</id>
    <revision>
      <id>16693</id>
      <parentid>16169</parentid>
      <timestamp>2021-12-06T22:07:08Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>30524</id>
      </contributor>
      <origin>16693</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="442" sha1="7sjlyaxr9usqwnrnzp7o1ocankzphsj" xml:space="preserve">&lt;includeonly&gt;
{{#arraymap: {{#ask: [[-Has subobject::{{#titleparts:{{{1|{{FULLPAGENAME}}}}}|1}}]]
 |mainlabel=-
 |?Course page
 |sort=Course page number
 |order=asc
 |format=array
 |sep=;
 |manysep=;
 |link=none
}}
 |;
 |@@@
 |
== {{#titleparts:@@@||-1}} ==
{{:@@@}}
 |\n
}}
__NOEDITSECTION__
{{DISPLAYTITLE:{{#titleparts:{{{1|{{FULLPAGENAME}}}}}|1}}}}
&lt;/includeonly&gt;&lt;noinclude&gt;
Displays all pages of the course on a single page.
&lt;/noinclude&gt;</text>
      <sha1>7sjlyaxr9usqwnrnzp7o1ocankzphsj</sha1>
    </revision>
  </page>
  <page>
    <title>Template:MerlinMultipageExperienceNavBar</title>
    <ns>10</ns>
    <id>8602</id>
    <revision>
      <id>16703</id>
      <parentid>16702</parentid>
      <timestamp>2021-12-06T22:14:47Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>30524</id>
      </contributor>
      <origin>16703</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1560" sha1="c2cf2gtfra4ezvz1xzgskha6e00vg9y" xml:space="preserve">&lt;includeonly&gt;{{#arraydefine: slides|{{#show:{{BASEPAGENAME}}|?Sequenced subpages}}|;}}
&lt;div class="{{#ifeq: {{#titleparts:{{FULLPAGENAME}}||-1}}|All|d-none|d-flex}} w-100 justify-content-between align-items-center"&gt;&lt;!--

--&gt;[[{{#ask: 
  [[-Has subobject::{{BASEPAGENAME}}]]
  [[Course page number::{{#arraysearch:slides|{{#titleparts:{{FULLPAGENAME}}||-1}}}}]]
  |?Course page
  |mainlabel=-
  |format=array
  |default={{BASEPAGENAME}}
}}|&lt;span class="btn btn-dark" title="Click to return to the prior page"&gt;&amp;laquo; Prior&lt;/span&gt;]]&lt;!--

--&gt;&lt;small class="d-flex flex-column flex-md-row justify-content-center align-items-center"&gt;[[{{BASEPAGENAME}}]] : {{#expr: 0{{#arraysearch:slides|{{#titleparts:{{FULLPAGENAME}}||-1}}}} + 1}} of {{#arraysize: slides}}&lt;/small&gt;&lt;!--

--&gt;[[{{#ask: 
   [[-Has subobject::{{BASEPAGENAME}}]]
   [[Course page number::{{#expr:0{{#arraysearch:slides|{{#titleparts:{{FULLPAGENAME}}||-1}}}} + 2}}]]
   |?Course page
   |mainlabel=-
   |format=array
   |default={{BASEPAGENAME}}
 }}|&lt;span class="btn btn-dark" title="Click to proceed to the next page"&gt;Next &amp;raquo;&lt;/span&gt;]]
&lt;/div&gt;&lt;!--

--&gt;{{#ifeq: {{#titleparts:{{FULLPAGENAME}}||-1}}|All|
     |{{DISPLAYTITLE:{{#titleparts:{{FULLPAGENAME}}||-1}}}}
   }}
&lt;/includeonly&gt;
&lt;noinclude&gt;
Adds navigation within the educational course.

;Usage
Place the template call on a page belonging to a Course (listed on the course cover page in the [[Template:MerlinMultipageExperienceSubpages|MerlinMultipageExperienceSubpages]] template):
&lt;pre&gt;
{{MerlinMultipageExperienceNavBar}}
&lt;/pre&gt;
&lt;/noinclude&gt;</text>
      <sha1>c2cf2gtfra4ezvz1xzgskha6e00vg9y</sha1>
    </revision>
  </page>
  <page>
    <title>Number Systems</title>
    <ns>0</ns>
    <id>211</id>
    <revision>
      <id>16699</id>
      <parentid>16689</parentid>
      <timestamp>2021-12-06T22:11:08Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>30524</id>
      </contributor>
      <origin>16699</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1018" sha1="p0rsq9kzju9lxfmt4md8g535hwz2gp4" xml:space="preserve">== Curriculum ==
{{MerlinCurriculumData|{{ROOTPAGENAME}}}}
== Experience ==
{{MerlinMultipageExperience}}
&lt;!-- NEW METHOD --&gt;
{{MerlinMultipageExperienceSubpages
  |Pages=Positional Notation;Alternative Bases;Formal Representation;Conversions from Decimal;Customs;Shortcut Conversions
}}
&lt;!-- OBSOLETE {{MerlinMultipageExperienceNavBar}} --&gt;
== Exercises ==
{{Exercises|
* {{MMMAssignment|M1011-10}}
}}
== References ==
* [https://en.wikipedia.org/wiki/Positional_notation Positional Notation] (Wikipedia) 
* [https://en.wikipedia.org/wiki/Radix Radix] (Wikipedia)
{{Experience
|experienceID=W1011
|experienceUnit=Numbers
|knowledgeAndSkills=§10.311
|topicAreas=Positional notation
|classroomTime=60 minutes
|studyTime=3 hours
|acquiredKnowledge=understand positional notation;
|acquiredSkill=ability to use positional notation to represent numbers in the binary, octal, decimal, and hexadecimal systems;
ability to convert between representations of numbers in the binary, octal, decimal, and hexadecimal systems;
}}</text>
      <sha1>p0rsq9kzju9lxfmt4md8g535hwz2gp4</sha1>
    </revision>
  </page>
  <page>
    <title>Number Systems/All</title>
    <ns>0</ns>
    <id>8567</id>
    <revision>
      <id>16682</id>
      <parentid>16348</parentid>
      <timestamp>2021-12-06T20:04:25Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>30524</id>
      </contributor>
      <origin>16682</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="58" sha1="m36d3d6crck578y0cccjtf9sijjfnl6" xml:space="preserve">{{MerlinTopics}}
&lt;!-- {{MerlinMultipageExperienceAll}} --&gt;</text>
      <sha1>m36d3d6crck578y0cccjtf9sijjfnl6</sha1>
    </revision>
  </page>
  <page>
    <title>Number Systems/Alternative Bases</title>
    <ns>0</ns>
    <id>8562</id>
    <revision>
      <id>16707</id>
      <parentid>16684</parentid>
      <timestamp>2021-12-06T22:16:36Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>30524</id>
      </contributor>
      <origin>16707</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="4985" sha1="oymua8mhrbr6x588kvhga8znge43689" xml:space="preserve">=== Number Base ===
The '''radix''' or '''base''' is the number of unique digits, ''including zero'', used to represent numbers in a positional numeral system. The base is normally written as a subscript to the right of the number. For example, the decimal number 123 would formally be written as (123)&lt;sub&gt;10&lt;/sub&gt;&lt;br /&gt;
Note that the parentheses are sometimes not written: 123&lt;sub&gt;10&lt;/sub&gt;&lt;br /&gt;
In the case of decimal (base 10) numbers, the subscripted 10 is often assumed and not written.

=== Decimal System ===
The decimal system is the system with which we are most familiar. It is a decimal system because it contains ten unique digits:&lt;br /&gt;
&lt;pre&gt;
0 1 2 3 4 5 6 7 8 9
&lt;/pre&gt;

For any (integer) value larger than 9, we’re required to use positional notation. Please keep in mind that “10” is not a digit. Rather, it’s a number consisting of two digits, a “1” in the tens (10&lt;sup&gt;1&lt;/sup&gt;) position and a “0” in the ones position (10&lt;sup&gt;0&lt;/sup&gt;).

=== Octal System ===
The octal system uses eight unique digits to represent a number:&lt;br /&gt;
&lt;pre&gt;
0 1 2 3 4 5 6 7
&lt;/pre&gt;

Let’s consider the value of an octal number: 4735&lt;sub&gt;8&lt;/sub&gt;

What is the ''decimal'' value of this number? We use exactly the same method that we use for knowing the value in any system:

{| class="wikitable" style="text-align:right;"
 | Digit at position:  || 4 || 7 || 3 || 5
 |-
 | Position multiplier: || 8&lt;sup&gt;3&lt;/sup&gt; || 8&lt;sup&gt;2&lt;/sup&gt; || 8&lt;sup&gt;1&lt;/sup&gt; || 8&lt;sup&gt;0&lt;/sup&gt;
 |-
 | Position value: || 4 &amp;bull; 8&lt;sup&gt;3&lt;/sup&gt; || 7 &amp;bull; 8&lt;sup&gt;2&lt;/sup&gt; || 3 &amp;bull; 8&lt;sup&gt;1&lt;/sup&gt; || 5 &amp;bull; 8&lt;sup&gt;0&lt;/sup&gt;
 |-
 |                 || 2048 || 448 || 24 || 5
 |}

Note that in this case, the right-most digit is, as always, representative of units (ones), just as in any positional system. However, moving one digit to the left, because we’re now using an octal system, the position indicates the number of eights (not tens). The next position to the left indicates the number of sixty-fours (not hundreds) and the final position indicates the number of 512’s. As before, we multiply each digit by its corresponding position multiplier to obtain the value of the entire number:

4 &amp;bull; 8&lt;sup&gt;3&lt;/sup&gt; + 7 &amp;bull; 8&lt;sup&gt;2&lt;/sup&gt; + 3 &amp;bull; 8&lt;sup&gt;1&lt;/sup&gt; + 5 &amp;bull; 8&lt;sup&gt;0&lt;/sup&gt; =&lt;br/&gt;
2,048&lt;sub&gt;10&lt;/sub&gt; + 448&lt;sub&gt;10&lt;/sub&gt; + 24&lt;sub&gt;10&lt;/sub&gt; + 5&lt;sub&gt;10&lt;/sub&gt; =&lt;br/&gt;
2,525&lt;sub&gt;10&lt;/sub&gt;

=== Hexadecimal System ===
The hexadecimal (six and ten) uses sixteen digits to represent a number:&lt;br /&gt;
&lt;pre&gt;
0 1 2 3 4 5 6 7 8 9 A B C D E F
&lt;/pre&gt;

Note that because we only have ten digits in our familiar decimal system, we use the letters A through F to represent the additional six digits in the hexadecimal system. Remember that these are ''digits'', that is, A represents 10, B represents 11, and so on up to F which represents 15.

Let’s consider the value of a hexadecimal number: B59C&lt;sub&gt;16&lt;/sub&gt;

What is the ''decimal'' value of this number? 

{| class="wikitable" style="text-align:right;"
 | Digit at position:  || B || 5 || 9 || C
 |-
 | Position multiplier: || 16&lt;sup&gt;3&lt;/sup&gt; || 16&lt;sup&gt;2&lt;/sup&gt; || 16&lt;sup&gt;1&lt;/sup&gt; || 16&lt;sup&gt;0&lt;/sup&gt;
 |-
 | Position value: || B &amp;bull; 16&lt;sup&gt;3&lt;/sup&gt; || 5 &amp;bull; 16&lt;sup&gt;2&lt;/sup&gt; || 9 &amp;bull; 16&lt;sup&gt;1&lt;/sup&gt; || C &amp;bull; 16&lt;sup&gt;0&lt;/sup&gt;
 |-
 |                 || 45,056 || 1280 || 144 || 12
 |}

As always, we multiply each digit by its corresponding position multiplier to obtain the value of the entire number:

B &amp;bull; 16&lt;sup&gt;3&lt;/sup&gt; + 5 &amp;bull; 16&lt;sup&gt;2&lt;/sup&gt; + 9 &amp;bull; 16&lt;sup&gt;1&lt;/sup&gt; + C &amp;bull; 16&lt;sup&gt;0&lt;/sup&gt; =&lt;br/&gt;
45,056&lt;sub&gt;10&lt;/sub&gt; + 1280&lt;sub&gt;10&lt;/sub&gt; + 144&lt;sub&gt;10&lt;/sub&gt; + 12&lt;sub&gt;10&lt;/sub&gt; =&lt;br/&gt;
46,492&lt;sub&gt;10&lt;/sub&gt;

=== Binary System ===
The binary system (two) uses two digits to represent a number:&lt;br/&gt;
&lt;pre&gt;
0 1
&lt;/pre&gt;

Let’s consider the value of a binary number: 1011 1010&lt;sub&gt;2&lt;/sub&gt;&lt;br/&gt;
What is the decimal value of this number?

{| class="wikitable" style="text-align:right;"
 | Digit at position:  || 1 || 0 || 1 || 1 || 1 || 0 || 1 || 0
 |-
 | Position multiplier: || 2&lt;sup&gt;7&lt;/sup&gt; || 2&lt;sup&gt;6&lt;/sup&gt; || 2&lt;sup&gt;5&lt;/sup&gt; || 2&lt;sup&gt;4&lt;/sup&gt; || 2&lt;sup&gt;3&lt;/sup&gt; || 2&lt;sup&gt;2&lt;/sup&gt; || 2&lt;sup&gt;1&lt;/sup&gt; || 2&lt;sup&gt;0&lt;/sup&gt;
 |-
 | Position value: || 1 &amp;bull; 2&lt;sup&gt;7&lt;/sup&gt; || 0 &amp;bull; 2&lt;sup&gt;6&lt;/sup&gt; || 1 &amp;bull; 2&lt;sup&gt;5&lt;/sup&gt; || 1 &amp;bull; 2&lt;sup&gt;4&lt;/sup&gt; || 1 &amp;bull; 2&lt;sup&gt;3&lt;/sup&gt; || 0 &amp;bull; 2&lt;sup&gt;2&lt;/sup&gt; || 1 &amp;bull; 2&lt;sup&gt;1&lt;/sup&gt; || 0 &amp;bull; 2&lt;sup&gt;0&lt;/sup&gt;
 |-
 |                 || 128 || 0 || 32 || 16 || 8 || 0 || 2 || 0
 |}

Multiplying each digit by its corresponding position multiplier to obtain the value of the entire number:

1 &amp;bull; 2&lt;sup&gt;7&lt;/sup&gt; + 0 &amp;bull; 2&lt;sup&gt;6&lt;/sup&gt; + 1 &amp;bull; 2&lt;sup&gt;5&lt;/sup&gt; + 1 &amp;bull; 2&lt;sup&gt;4&lt;/sup&gt; + 1 &amp;bull; 2&lt;sup&gt;3&lt;/sup&gt; + 0 &amp;bull; 2&lt;sup&gt;2&lt;/sup&gt; + 1 &amp;bull; 2&lt;sup&gt;1&lt;/sup&gt; + 0 &amp;bull; 2&lt;sup&gt;0&lt;/sup&gt; =&lt;br/&gt;
128&lt;sub&gt;10&lt;/sub&gt; + 0&lt;sub&gt;10&lt;/sub&gt; + 32&lt;sub&gt;10&lt;/sub&gt; + 16&lt;sub&gt;10&lt;/sub&gt; + 8&lt;sub&gt;10&lt;/sub&gt; + 0&lt;sub&gt;10&lt;/sub&gt; + 2&lt;sub&gt;10&lt;/sub&gt; + 0&lt;sub&gt;10&lt;/sub&gt; =&lt;br/&gt;
186&lt;sub&gt;10&lt;/sub&gt;


&lt;noinclude&gt;{{MerlinMultipageExperienceNavBar}}&lt;/noinclude&gt;</text>
      <sha1>oymua8mhrbr6x588kvhga8znge43689</sha1>
    </revision>
  </page>
  <page>
    <title>Number Systems/Conversions from Decimal</title>
    <ns>0</ns>
    <id>8564</id>
    <revision>
      <id>16709</id>
      <parentid>16686</parentid>
      <timestamp>2021-12-06T22:17:18Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>30524</id>
      </contributor>
      <origin>16709</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="2455" sha1="fbnj8iru5xjqmuyawewdec8pex73h8f" xml:space="preserve">To convert a decimal (base 10) number to any other base, we simply repeatedly divide by the base until we have a quotient of zero. Specifically, the dividend starts with the number that we want to convert, the divisor will always be the base. The remainder of each successive operation indicates the digit in the new base first at the right-most position and then moving left. The quotient of each step becomes the dividend of the subsequent step.

Let’s first try converting the number 28&lt;sub&gt;10&lt;/sub&gt; to octal (base 8):

The dividend is the decimal number that we want to convert, in this case 28.
The divisor is the base to which we want to convert, in this case 8.
The remainder indicates each successive digit. We stop the process when the quotient is 0.

{| class="wikitable" style="text-align:right;"
 ! Step !! Dividend !! Divisor !! Quotient !! Remainder
 |-
 | 1 || 28 || 8 || 3 || 4
 |-
 | 2 || 3 || 8 || 0 || 3
 |}

So, 28&lt;sub&gt;10&lt;/sub&gt; is 34&lt;sub&gt;8&lt;/sub&gt;. (Remember that we read the remainder from bottom to top.)

Let’s try converting the number 567&lt;sub&gt;10&lt;/sub&gt; to octal:

{| class="wikitable" style="text-align:right;"
 ! Step !! Dividend !! Divisor !! Quotient !! Remainder
 |-
 | 1 || 567 || 8 || 70 || 7
 |-
 | 2 || 70 || 8 || 8 || 6
 |-
 | 3 || 8 || 8 || 1 || 0
 |-
 | 4 || 1 || 8 || 0 || 1
 |}

So, 567&lt;sub&gt;10&lt;/sub&gt; is 1067&lt;sub&gt;8&lt;/sub&gt;.

Let’s try converting the number 63,215&lt;sub&gt;10&lt;/sub&gt; to hexadecimal:

{| class="wikitable" style="text-align:right;"
 ! Step !! Dividend !! Divisor !! Quotient !! Remainder
 |-
 | 1 || 63215 || 16 || 3950 || 15
 |-
 | 2 || 3950 || 16 || 246 || 14
 |-
 | 3 || 246 || 16 || 15 || 6
 |-
 | 4 || 15 || 16 || 0 || 15
 |}

So, 63,215&lt;sub&gt;10&lt;/sub&gt; is hexadecimal [15][6][14][15], or more conventionally, F6EF&lt;sub&gt;16&lt;/sub&gt;. &lt;br/&gt;
(Remembering that in hexadecimal, we use the digit “F” for 15, “E” for 14, etc.)


Finally, let’s convert the number 53410 to binary:

{| class="wikitable" style="text-align:right;"
 ! Step !! Dividend !! Divisor !! Quotient !! Remainder
 |-
 | 1 || 534 || 2 || 267 || 0
 |-
 | 2 || 267 || 2 || 133 || 1
 |-
 | 3 || 133 || 2 || 66 || 1
 |-
 | 4 || 66 || 2 || 33 || 0
 |-
 | 5 || 33 || 2 || 16 || 1
 |-
 | 6 || 16 || 2 || 8 || 0
 |-
 | 7 || 8 || 2 || 4 || 0
 |-
 | 8 || 4 || 2 || 2 || 0
 |-
 | 9 || 2 || 2 || 1 || 0
 |-
 | 10 || 1 || 2 || 0 || 1
 |}

So, 534&lt;sub&gt;10&lt;/sub&gt; is 10 0001 0110&lt;sub&gt;2&lt;/sub&gt;


&lt;noinclude&gt;{{MerlinMultipageExperienceNavBar}}&lt;/noinclude&gt;</text>
      <sha1>fbnj8iru5xjqmuyawewdec8pex73h8f</sha1>
    </revision>
  </page>
  <page>
    <title>Number Systems/Customs</title>
    <ns>0</ns>
    <id>8565</id>
    <revision>
      <id>16710</id>
      <parentid>16687</parentid>
      <timestamp>2021-12-06T22:17:37Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>30524</id>
      </contributor>
      <origin>16710</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="701" sha1="o33c6dsij7pd9cfewj1j7fvd6ver4d2" xml:space="preserve">* It is customary to separate groups of three '''decimal''' digits by commas.  For example:  123,456&lt;sub&gt;10&lt;/sub&gt;.
* It is customary to separate groups to two '''hexadecimal''' digits by spaces and prefix a leading zero to what would otherwise be a single digit.  For example: 01 2F&lt;sub&gt;16&lt;/sub&gt;.
* It is customary to separate groups of three '''octal''' digits by spaces and prefix leading zeros to pad to a three digit grouping.  For example: 001 237&lt;sub&gt;8&lt;/sub&gt;.
* It is customary to separate groups of four '''binary''' digits by spaces and prefix leading zeroes to pad to a four digit grouping.  For example: 0001 1011 1100&lt;sub&gt;2&lt;/sub&gt;.

&lt;noinclude&gt;{{MerlinMultipageExperienceNavBar}}&lt;/noinclude&gt;</text>
      <sha1>o33c6dsij7pd9cfewj1j7fvd6ver4d2</sha1>
    </revision>
  </page>
  <page>
    <title>Number Systems/Formal Representation</title>
    <ns>0</ns>
    <id>8563</id>
    <revision>
      <id>16708</id>
      <parentid>16685</parentid>
      <timestamp>2021-12-06T22:16:58Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>30524</id>
      </contributor>
      <origin>16708</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="780" sha1="69e89rngsbx43hzzblfdxnzhh0u8e98" xml:space="preserve">Let x be a string of digits, such that:
&lt;math&gt;x = x_{n}x_{n-1}x_{n-2} \cdots x_{0}&lt;/math&gt;

Then, the value of &lt;math&gt;x&lt;/math&gt; in any particular base, &lt;math&gt;b&lt;/math&gt;, is calculated as:
&lt;math&gt;\sum_{i=0}^{n} x_{i} \cdot b^i&lt;/math&gt;

The rightmost digit, &lt;math&gt;x_{0}&lt;/math&gt; is referred to as the '''least significant digit''', or '''LSD'''.  It is ''least significant'' because in terms of the overall value of the entire number, this digit will always have the least impact.  Conversely, the leftmost digit, &lt;math&gt;x_{n}&lt;/math&gt; is referred to as the '''most significant digit''', or '''MSD'''.  It is ''most significant'' because in terms of the overall value of the entire number, this digit will always have the most impact.

&lt;noinclude&gt;{{MerlinMultipageExperienceNavBar}}&lt;/noinclude&gt;</text>
      <sha1>69e89rngsbx43hzzblfdxnzhh0u8e98</sha1>
    </revision>
  </page>
  <page>
    <title>Number Systems/Positional Notation</title>
    <ns>0</ns>
    <id>8561</id>
    <revision>
      <id>16706</id>
      <parentid>16683</parentid>
      <timestamp>2021-12-06T22:16:12Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>30524</id>
      </contributor>
      <origin>16706</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="1849" sha1="iw5awt6hvvdz9u5uwkbmq77eitdqypu" xml:space="preserve">'''Positional notation''' (sometimes called '''place-value notation''') is a method of encoding numbers. It differs from other notations (such as Roman numerals) in that it uses the same symbol for different orders of magnitude depending on its position. For example, consider the number 23. The “3” indicates 3 ''ones'', because it is in the ''ones'' position. The “2”, however, indicates 2 ''tens'', because it is in the ''tens'' position. We know the value of a position by its location within the number. As we move ''left'' in a number, each position is valued at ten times the prior position. It might help if we label each position using power notation. Consider the number 123:

[[File:Positional Notation.png]]

The “3” is the right-most, and therefore the lowest-valued position, representing “ones” with a position multiplier of 10&lt;sup&gt;0&lt;/sup&gt; (that is, 10 raised to the zero power, or 1). The “2” is located one position to the left, so we multiply by 10 again giving us a position multiplier of 10&lt;sup&gt;1&lt;/sup&gt; (that is, 10 raised to the first power, or 10). Finally, the “1” is located one position to the left, so we again multiply by 10 giving us a position multiplier of 10&lt;sup&gt;2&lt;/sup&gt; (that is, 10 raised to the second power, or 100). By multiplying each digit by its corresponding position multiplier, we can obtain the value of the entire number:

1 * 10&lt;sup&gt;2&lt;/sup&gt; + 2 * 10&lt;sup&gt;1&lt;/sup&gt; + 3 * 10&lt;sup&gt;0&lt;/sup&gt; =&lt;br /&gt;
100 + 20 + 3 =&lt;br /&gt; 
123&lt;br /&gt;

While we generally understand the mechanics of this process in the decimal system, thinking about how it actually works will enable us to consider other systems.

{{MerlinVideoPlayer|videoID=sEb5M2zyCxQ02de00E4bYrotYH3dsd016u01DlBYQw00hOfo|videoTitle=Interpreting nubers based on their position}}

&lt;noinclude&gt;{{MerlinMultipageExperienceNavBar}}&lt;/noinclude&gt;</text>
      <sha1>iw5awt6hvvdz9u5uwkbmq77eitdqypu</sha1>
    </revision>
  </page>
  <page>
    <title>Number Systems/Shortcut Conversions</title>
    <ns>0</ns>
    <id>8566</id>
    <revision>
      <id>16711</id>
      <parentid>16688</parentid>
      <timestamp>2021-12-06T22:17:59Z</timestamp>
      <contributor>
        <username>Anton-krom</username>
        <id>30524</id>
      </contributor>
      <origin>16711</origin>
      <model>wikitext</model>
      <format>text/x-wiki</format>
      <text bytes="3261" sha1="rtekkab5qgq8e5o5zu510xcyaro27tz" xml:space="preserve">Because both the octal and hexadecimal bases contain &lt;math&gt;2^3&lt;/math&gt; and &lt;math&gt;2^4&lt;/math&gt; possible digits, respectively, and the binary base contains &lt;math&gt;2^1&lt;/math&gt; possible digits, we're able to utilize a shortcut when converting between these systems.  Note that each octal digit is comprised of three binary digits and each hexadecimal digit is comprised of four binary digits.  We can therefore establish (and '''memorize''') the following table:

{| class="wikitable"
!Decimal
!Binary
!Octal
!Hexadecimal
|-
|00
|0000
|00
|0
|-
|01
|0001
|01
|1
|-
|02
|0010
|02
|2
|-
|03
|0011
|03
|3
|-
|04
|0100
|04
|4
|-
|05
|0101
|05
|5
|-
|06
|0110
|06
|6
|-
|07
|0111
|07
|7
|-
|08
|1000
|10
|8
|-
|09
|1001
|11
|9
|-
|10
|1010
|12
|A
|-
|11
|1011
|13
|B
|-
|12
|1100
|14
|C
|-
|13
|1101
|15
|D
|-
|14
|1110
|16
|E
|-
|15
|1111
|17
|F
|}

The shortcut is very straight-forward yet a significant time saver and based on the above information.  When converting between binary, octal, and hexadecimal, there's no need to use an intermediate, decimal step.  

=== Binary to Hexadecimal ===
Group the binary number in sets of four digits, from right to left.  Each binary set represents a single hexadecimal digit.  (It's sometimes helpful to pad the final set with zeroes.)  For example, given the number &lt;math&gt;11000111\;\;00100101_{2}&lt;/math&gt;, regroup the binary digits in sets of four:&lt;br/&gt; 
&lt;math&gt;11000111\;\;00100101_{2}&lt;/math&gt;&lt;br/&gt;
&lt;math&gt;\color{Orange}1100\color{Blue}0111\;\;\color{Orange}0010\color{Blue}0101\color{Black}_{2}&lt;/math&gt;&lt;br/&gt;
&lt;math&gt;\color{Orange}1100\;\;\color{Blue}0111\;\;\color{Orange}0010\;\;\color{Blue}0101\color{Black}_{2}&lt;/math&gt;.&lt;br/&gt;

Then, use the memorized table to translate each set of four binary digits to a single hexadecimal digit:

{| class="wikitable"
| 1100
| 0111
| 0010
| 0101
|-
| C 
| 7   
| 2 
| 5
|}

=== Hexadecimal to Binary ===
Simply follow the above procedure in reverse.  Use the memorized table to convert each hexadecimal digit to a set of four binary digits.

=== Binary to Octal ===
Group the binary number in sets of three digits, from right to left.  Each binary set represents a single octal digit.  (It's sometimes helpful to pad the final set with zeroes.)  For example, given the number &lt;math&gt;11000111\;\;00100101_{2}&lt;/math&gt;, regroup the binary digits in sets of three:&lt;br/&gt; 
&lt;math&gt;11000111\;\;00100101_{2}&lt;/math&gt;&lt;br/&gt;
&lt;math&gt;\color{Orange}1\color{Blue}100\color{Orange}011\color{Blue}1\;\;00\color{Orange}100\color{Blue}101\color{Black}_{2}&lt;/math&gt;&lt;br/&gt;
&lt;math&gt;00\color{Orange}1\;\;\color{Blue}100\;\;\color{Orange}011\;\;\color{Blue}100\;\;\color{Orange}100\;\;\color{Blue}101\color{Black}_{2}&lt;/math&gt;.&lt;br/&gt; 

Then, use the memorized table to translate each set of three binary digits to a single octal digit:

{| class="wikitable"
| 001
| 100 
| 011 
| 100 
| 100 
| 101
|-
| 1  
| 4  
| 3  
| 4   
| 4 
| 5
|}

=== Octal to Binary ===
Simply follow the above procedure in reverse.  Use the memorized table to convert each octal digit to a set of three binary digits.

=== Octal to Hexadecimal (and vice versa) ===
This requires slightly more work.  Convert the number in the source base to binary, and then convert from binary to the target base.


&lt;noinclude&gt;{{MerlinMultipageExperienceNavBar}}&lt;/noinclude&gt;</text>
      <sha1>rtekkab5qgq8e5o5zu510xcyaro27tz</sha1>
    </revision>
  </page>
</mediawiki>