UNIX and Linux
Contents
UNIX and Linux#
The time has come,’ the Walrus said, To talk of many things: Of shoes — and ships — and sealing-wax — Of cabbages — and kings — And why the sea is boiling hot — And whether pigs have wings.’
—Lewis Carroll
Introduction#
Here we are going to learn about the UNIX operating system, and in particular, it’s most popular user-friendly avatar, Linux (and even more specifically, Debian based Linux distributions, with focus on Ubuntu). If you are not a Unix/Linux user, you still need to learn the UNIX environment because under the hood, all other operating systems that need to do serious computing have to use Unix. Indeed, MacOS is built on UNIX, and Windows now a days has a UNIX sub-system to enable users to things that can only really be done in UNIX (like Genomics!).
What is UNIX?#
UNIX is a machine-independent operating system (OS) developed in the 1970s by AT&T programmers (notably Brian Kernighan and Dennis Ritchie, fathers of C
) for programmers (you!). It is multi-user and network-oriented by design, uses plain text files for storing data (no proprietary file formats), and has a strictly hierarchical directory structure (more on this below). This makes it an ideal environment for developing your code and storing your data.
Linux and Mac OS are Unix-like (or UN*X or *nix) operating systems that have evolved from UNIX. Ubuntu is a Linux distribution.
Why UNIX?#
It was designed for developing code and storing data – an ideal native habitat for programming languages like Python and R
Robust, stable, secure (very few UNIX viruses and malware – I am yet to encounter one after almost 15 years!)
Its free and open-source
Scores of small programs available to perform simple tasks – can be combined easily
Easy to automate tasks (e.g., using shell scripts)
Multi-user (multiple users can log in and concurrently use computer)
Multi-tasking (can perform many tasks at the same time)
Network-ready (easy to communicate between computers)
Amazing support – a large body of tutorials and support web sites are readily available online
Basically all resources for High-Performance Computing (computer clusters, large workstations, etc.) run a UNIX or Linux operating system
UNIX has been around since the early 1970’s and will likely be around at the end of your career (the hard work you are putting into learning UNIX will pay off over a lifetime!)
Note
32-bit vs 64-bit: The terms 32-bit and 64-bit refer to the way a computer’s processor (also called a CPU), handles information. A 64-bit OS handles large amounts of random access memory (RAM) more effectively than a 32-bit system. Specifically, while 32 bits of information can only access 4 GB of RAM, a 64-bit machine can access essentially unlimited system memory (though this is not yet physically possible)! The combination of your operating system, and processor bit count is often called the “Platform”.
UNIX directory structure#
The key UNIX directories are:
Directory |
Description |
|---|---|
|
Is the “root” directory |
|
Contains basic programs |
|
Contains configuration files |
|
Contains files connecting to devices (keyboard, mouse, screen, etc.) |
|
Your home directory; this is where all your documents are and where you will usually work |
|
Contains temporary files |
This hierarchical directory structure makes navigating your computer from the terminal/shell (coming up next!) or encoding this navigation in your computer programs easier.
Meet the UNIX shell#
The shell (or terminal) is a text command processor that can run commands to interface with the Operating System’s “kernel” – the core software that “talks” to the harware, including the CPU, RAM and hard drive. We will use the popular (yes, it’s very popular in the new universe you are entering!) bash
shell.
Note
bash
stand for the “B
ourne A
gain Sh
ell”, a pun (“born again” oh, us geeks!) on the name of the original Bourne shell (sh
) that it replaces.
\(\star\) To launch a bash
shell, do Ctrl + Alt + t
(or use Meta
key) – try it now. (On Mac: Cmd+Space
to open spotlight search, and type “terminal” and hit return).
Warning
In Mac OS, the default shell will likely be zsh
shell, assuming you are using one of the newer versions of the operating system. Most of the commands will be the same between these shells, but some may differ (look out for tips about this, and also read this).
OK, so you have met the shell. Isn’t it lovely?
Let’s look at key features of the bash shell/terminal:
The shell, by default, automatically starts in your home directory
/home/yourname/
The start of the command prompt, where you will type your commands is indicated by a
:~$
)The text before the
:~$
tells you what the name of the current user is (the part before the@
), and the name of the computer (the part after the@
upto the:~$
).
Tip
The path /home/yourname/
can be replaced with shorthand ~
(important to remember!). So, for example, the command cd /home/yourname/Documents
is the same as the command cd ~/Documents
Some useful keyboard shortcuts that work in the bash terminal are:
Command |
What it means |
|---|---|
|
Go to the beginning of the line |
|
Go to the end of the line |
|
Clear the screen |
|
Clear the line before cursor position |
|
Clear the line after the cursor |
|
Kill whatever you are running |
|
Exit (close) the current shell |
|
Move cursor forward one whole word |
|
Move cursor backward one whole word |
Also, note that:
Use the
Tab
key – very handy (tryls
with a doubleTab
Tab
).You can navigate commands you previously typed using the up/down arrows
Special Characters#
Certain “special” characters have a particular meaning (and use) to the UNIX shell. The forward slash /
that separates parts of file/ directory paths, and the tilde ~
that serves as a shorthand for your home
directory path are two examples that you have already seen.
The following table gives the meanings of important (not all) special characters in shell command lines that you should know about (we will see more or different special characters as we go through the Shell scripting and Python chapters):
Special character |
Meaning |
|---|---|
|
Home directory path |
|
Path names separator |
|
Comment (anything after this will be ignored by the shell interpreter; in fact, this serves the same purpose across shell scripts, |
|
Variable, expression or command to follow this |
|
Start and end of an expression or command block |
|
Wildcard for strings; for example, |
|
Single-character wildcard |
|
Escape character; any character following this will be quoted; for example, |
|
Command separator; commands can be entered sequentially in a single command line separated by this |
` |
` |
|
Redirect output to (any valid) target following this |
|
Pipeline logical NOT |
Basic UNIX commands#
Here are some basic commands, many of which you will use frequently.
Command |
What it does |
|---|---|
|
Show help page of a command. |
|
Display your user-name. |
|
Show the current directory. |
|
List the files in the directory. |
|
Change directory. |
|
Move one directory up. |
|
Go to the root directory. |
|
Go to the home directory. |
|
Copy a file, or a directory non-recursively (what’s this? Google it!). |
|
Copy a directory recursively (what’s this? Google it!). |
|
Move or rename a file or directory. |
|
Create an empty file. |
|
Print a string (in this example, “My string”). |
|
Remove a file or directory non-recursively. |
|
Remove a directory recursively. |
|
Count the number of lines and words in a file. |
|
Sort the lines of a file and print result. |
|
Shows only unique elements of a list. |
|
Print the file on the screen. |
|
Progressively print a file on the screen (“q” to exit). |
|
Print the first few lines of a file. |
|
Print the last few lines of a file. |
|
Show the last commands you typed. |
|
Print current date. |
|
Determine the type of a file. |
|
Change user password. |
|
Change file permissions. |
Exploring files and directories#
A fundamental command that you will probably use the most frequently of all is ls
(this stands for list files and directories in current directory).
\(\star\) Type the ls
command in at the command prompt (which will have opened in your home
directory) and hit Enter.
You will see a number of directories and maybe some files in the output (this is currently what you have in your user account’s home
).
\(\star\) Next try ls /
This will list what you have in your root, including the directories listed in the table above .
\(\star\) The ls
command by default does not list hidden directories and files. To see these, use
ls -a
This will list all files and directories that start with a .
, such as .config
(this contains sub-directories and files containing the configuration settings for applications).
\(\star\) To see more info on the files and directories, use
ls -l
And if you want to see detailed info on ALL files and directories including hidden ones, combine the -a
and -l
flags:
ls -al
An example line in the output of ls -l
is:
drwxr-xr-x 9 mhasoba mhasoba 4096 Oct 11 10:45 Desktop
This is what all that text preceding the folder name (in his case, Desktop
) means (you will get similar info for files):
Item type and permissions (
drwxr-xr-x
)The first letter is
d
because this is a directory. This will most often bed
(directory),-
(file), orl
(a symbolic link – a file that contains a reference to another file or directory, similar to a “shortcut” in Windows OS).Following this, there are three triplets of letters (
rwx
,r-x
,r-x
), with each letter in each of the three indicating read, write and execute permissions for the owner, the group, and anybody else.The first,
rwx
, indicates that the owner (mhasoba
, see below) has read (r
), write (w
) and execute (x
) permissions for the Desktop directoryThe second and third
r-x
mean that the group and everybody else have read and execute but not write permission (they can view the Desktop, but not modify anything in it)
Number of links or directories inside this directory (
9
) (for files this value would be 1)Who owns it (user
mhasoba
),The owner’s group (also
mhasoba
; on this machine the root is the (single) usermhasoba
),File size in bytes (
4096
),Time of last modification (
Oct 11 10:45
), andFile/directory name (
Desktop
)
Building your coursework directory structure#
It is time to start building your CMEE coursework directory structure. Please follow these rules:
Do all your work in a single directory with the abbreviation of your course followed by
CourseWork
(no spaces please) located in a suitable place in your/home
. So for example, for CMEE students, the directory would beCMEECourseWork
.Each week’s coursework should be in its respective directory; e.g.,
CMEECourseWork/week1
,CMEECourseWork/week2
, etc.Each week’s directory should contain directories called
code
,data
,results
, andsandbox
(can be all small(like in these example names), sentence (first letter capitalized), or all large case, but be consistent)
You will bring your CMEECourseWork
and all it’s contents under version control using Git (coming up in the Version Control Chapter.
\(\star\) OK, make your coursework directory now. First, cd
to an appropriate place (e.g., Documents
on your home
):
cd ~/Documents # same as /home/YourUserName/Documents
Check what you have in there with:
ls
(You should see the contents of your Documents
directory)
Now make the directory and cd
to it
mkdir CMEECourseWork
You will get an error if a directory by that name already exists.
cd CMEECourseWork
You can also combine commands using &&
. For example,
cd CMEECourseWork && cd CMEECourseWork
Next, create your week1 sub-directory:
mkdir week1
cd week1
mkdir sandbox code data results
Then, try to cd to it:
cd Sandbox
You will get bash: cd: Sandbox: No such file or directory
error, because in the UNIX/Linux file system, commands are case-sensitive. So “Sandbox
” is not the same as “sandbox
”.
Warning
Mac OS has case insensitive commands: Unlike UNIX/Linux, MacOS allows execution of commands and file/directory names in a case-insensitive way. Keep this in mind from the perspective of platform independence - if you write your code to call a directory called, say, Sandbox
, but the directory is actually called sandbox
, then you will not get an error, but your collaborator (me!) will, if she/he uses Linux!
Next, try and remove sandbox
:
rm sandbox
You will get a rm: cannot remove 'sandbox': Is a directory
error because UNIX is conservative about allowing users to delete directories (this is one of the reasons why it is so stable). To delete it, you will need to use the -r
(for recursive) flag:
rm -r sandbox
Careful with the -r
option, because starting with the target directory (sandbox
in this case), it r
ecursively removes the entire directory tree inside the target directory, files and all!
Now recreate your sandbox
:
mkdir sandbox
Let’s try renaming it:
mv sandbox Sandbox
ls
code data results Sandbox
Let’s move back to all small caps sandbox
for naming consistency:
mv Sandbox sandbox
ls
code data results sandbox
Next try some more directory and file manipulations:
cd sandbox
Try pwd
(p
rint w
orking d
irectory) next to see the full path of the current directory.
Let’s continue:
ls # nothing here yet
Note the hash mark (#
) after the command above – anything after a #
is ignored (so you can use it for commenting).
touch TestFile # OR, "touch TestFile.txt"
ls
TestFile
mv TestFile TestFile2; ls # commands can also be sequentially executed with a `;`
TestFile2
rm TestFile2
You could have made your project directories and subdirectories in one swoop by using the -p
option of mkdir
(cd
back up to CMEECourseWork
first) with the -p
flag for mkdir
:
mkdir -p Week1/{Data,Code,Results,Sandbox}
How would you cd
to CMEECourseWork
?
There are two reasonable options:
cd ../../../CMEECourseWork
Or,
cd /home/YourUserName/Documents/CMEECourseWork
Try them both.
Which is the same as cd ~/Documents/CMEECourseWork
Which of these two would you choose and why?
Command arguments#
Most UNIX commands accept arguments that modify their behavior. E.g., ls -l
(ls “minus”l) lists the files in longer format. Some useful arguments:
Command/Argument |
What it does |
|---|---|
|
Copy a directory recursively (i.e., including all the sub-directories and files). |
|
Removes a file, but asks first (for safety). |
|
Remove a directory recursively (i.e., including all the sub-directories and files). |
|
List all files, including hidden ones. |
|
List all files, with human-readable sizes (Mb, Gb). |
|
List all files, long format. |
|
List all files, order by size. |
|
List all files, order by modification time. |
|
List all files, one file per line. |
|
Create the directory Dir3 and Dir1 and Dir2 if they do not already exist. |
|
Sort all the lines, but use numeric values instead of dictionary (i.e., 11 follows 2). |
You can also combine command arguments / flags. Try:
cd ../../ # cd two directory levels higher, assuming you are currently in CMEECourseWork/Week1/sandbox
ls -R
.:
week1
./week1:
code data results sandbox
./week1/code:
./week1/data:
./week1/results:
./week1/sandbox:
-R
flag lists directory tree recursively (through all subdirectories)
ls -lR # same as ls -l -R
.:
total 4
drwxrwxr-x 6 mhasoba mhasoba 4096 Oct 5 12:00 week1
./week1:
total 16
drwxrwxr-x 2 mhasoba mhasoba 4096 Oct 5 12:00 code
drwxrwxr-x 2 mhasoba mhasoba 4096 Oct 5 12:00 data
drwxrwxr-x 2 mhasoba mhasoba 4096 Oct 5 12:00 results
drwxrwxr-x 2 mhasoba mhasoba 4096 Oct 5 12:00 sandbox
./week1/code:
total 0
./week1/data:
total 0
./week1/results:
total 0
./week1/sandbox:
total 0
The combines -l
and -R
to give you both the directory permissions info and when it was modfied while listing the directories and files recursively.
Redirection and pipes#
Output of programs can also be “redirected” to a file in two ways:
>
: Redirect output from a command to a file on disk. If the file already exists, it will be overwritten.>>
: Append the output from a command to a file on disk. If the file does not exist, it will be created.
Let’s try some examples.
First make sure you are back in sandbox
:
cd week1/sandbox
echo "My first line." > test.txt
cat test.txt
My first line.
echo "My second line" >> test.txt
cat test.txt
My first line.
My second line
Now try
ls / >> ListRootDir.txt
cat ListRootDir.txt
What do you see? Cool!
We can also concatenate commands using “pipes” with “|
” e.g., to count how many files are in root (/
) directory:
ls / | wc -l
How many is that?
Look up man wc
in the terminal, or search “unix wc” online.
Or try:
ls -lt | head -5
total 4
-rw-rw-r-- 1 mhasoba mhasoba 30 Oct 5 12:01 test.txt
What does this do?
Wildcards#
We can use wildcards to find files based on their names (still in Week1/Sandbox
):
mkdir TestWild
cd TestWild
touch File1.txt
touch File2.txt
touch File3.txt
touch File4.txt
touch File1.csv
touch File2.csv
touch File3.csv
touch File4.csv
touch Anotherfile.csv
touch Anotherfile.txt
ls
ls | wc -l
Anotherfile.csv File1.csv File2.csv File3.csv File4.csv
Anotherfile.txt File1.txt File2.txt File3.txt File4.txt
10
We will use the following wildcards:
Wildcard |
Meaning |
|---|---|
|
Any single character, except a leading dot (hidden files). |
|
Zero or more characters, except a leading dot (hidden files). |
|
Define a class of characters (e.g., upper-case letters). |
Now let’s try to find the files using wildcards:
ls *
ls File*
ls *.txt
ls File?.txt
ls File[1-2].txt
ls File[!3].*
Anotherfile.csv File1.csv File2.csv File3.csv File4.csv
Anotherfile.txt File1.txt File2.txt File3.txt File4.txt
File1.csv File2.csv File3.csv File4.csv
File1.txt File2.txt File3.txt File4.txt
Anotherfile.txt File1.txt File2.txt File3.txt File4.txt
File1.txt File2.txt File3.txt File4.txt
File1.txt File2.txt
File1.csv File1.txt File2.csv File2.txt File4.csv File4.txt
Using grep
#
grep
is a command that matches strings in a file (why is this useful?). It is based on regular expressions (more on this later). Let’s explore some basic usage of grep
. For a test file let’s download a list of protected species from the web (to sandbox
):
cd ../ # move one level up from TestWild, back to sandbox
wget https://raw.githubusercontent.com/mhasoba/TheMulQuaBio/master/content/data/spawannxs.txt #Cool!
--2021-10-05 12:01:21-- https://raw.githubusercontent.com/mhasoba/TheMulQuaBio/master/content/data/spawannxs.txt
Resolving raw.githubusercontent.com (raw.githubusercontent.com)... <IP_ADDRESS>, <IP_ADDRESS>, <IP_ADDRESS>, ...
Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|<IP_ADDRESS>|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 13467 (13K) [text/plain]
Saving to: ‘spawannxs.txt’
spawannxs.txt 100%[===================>] 13.15K --.-KB/s in 0.003s
2021-10-05 12:01:21 (5.03 MB/s) - ‘spawannxs.txt’ saved [13467/13467]
ls
spawannxs.txt test.txt TestWild
mv spawannxs.txt ../data # Move the file to the appropriate location (note the ../ - relative path)
cd ../data # Move to the data directory
head -n 50 spawannxs.txt #You will see "head" in R and Python as well
ANNEX I
List of Species of Marine and Coastal Flora
Protected Under Article 11(1)(a)
TRACHAEOPHYTA (Vascular Plants)
Family Genus Species
Aquifoliaceae Ilex cookii
Bignoniaceae Crescentia mirabilis
Bignoniaceae Crescentia portoricensis
Boraginaceae Cordia wagnerorum
Buxaceae Buxus vahlii
Cactaceae Echinocereus reichenbachii var. albertii
Cactaceae Harrisia fragrans
Cactaceae Harrisia portoricensis
Cactaceae Leptocereus grantianus
Cactaceae Leptocereus wrightii
Cactaceae Melocactus guitartii
Cactaceae Melocactus harlowii sensu lato
Cactaceae Pilosocereus deeringii
Cactaceae Pilosocereus robinii
Convolvulaceae Bonamia grandiflora
Convolvulaceae Ipomoea flavopurpurea
Convolvulaceae Ipomoea walpersiana
Cyatheaceae Cyathea dryopteroides
Cyperaceae Rhynchospora bucherorum
Dioscoreaceae Rajania theresensis
Ericaceae Rhododendron chapmanii
Euphorbiaceae Andrachne brittonii
Euphorbiaceae Bernardia venosa
Euphorbiaceae Cnidoscolus fragrans
Euphorbiaceae Drypetes triplinervia
Flacourtiaceae Banaras vanderbiltii
Flacourtiaceae Samyda microphylla
Hydrophyllaceae Hydrolea torroei
Icacinaceae Ottoschulzia rhodoxylon
Leguminosae Acacia cupeyensis
(Fabaceae)
Leguminosae Acacia roigii
Leguminosae Stahlia monosperma
Liliaceae Harperocallis flava
Loranthaceae Dendropemon acutifolius
Malvaceae Abutilon virginianum
Meliaceae Trichilia triacantha
Olacaceae Ximenia roigii
Orchidaceae Brachionidium ciliolatum
Orchidaceae Cranichis ricartii
Orchidaceae Lapanthes eltoroensis
Orchidaceae Oncidium jacquinianum
OK, let’s look for falcons:
grep Falco spawannxs.txt
Falconidae Falco femoralis septentrionalis
Falconidae Falco peregrinus
Falconidae Polyborus plancus
Falconidae Falco columbarius
Nothing there? Let’s use -i
to make the matching case-insensitive:
grep -i Falco spawannxs.txt
Order: FALCONIFORMES
Falconidae Falco femoralis septentrionalis
Falconidae Falco peregrinus
Falconidae Polyborus plancus
Order: FALCONIFORMES
Order: FALCONIFORMES
Order: FALCONIFORMES
Falconidae Falco columbarius
Now let’s find the beautiful “Ara” macaws:
grep -i ara spawannxs.txt
Flacourtiaceae Banaras vanderbiltii
Order: CHARADRIIFORMES
Charadriidae Charadrius melodus
Psittacidae Amazona arausica
Psittacidae Ara macao
Dasyproctidae Dasyprocta guamara
Palmae Syagrus (= Rhyticocos) amara
Psittacidae Ara ararauna
Psittacidae Ara chloroptera
Psittacidae Arao manilata
Mustelidae Eira barbara
Order: CHARADRIIFORMES
But this poses a problem (What is the problem?).
We can solve this by specifying -w
to match only full words:
grep -i -w ara spawannxs.txt
Psittacidae Ara macao
Psittacidae Ara ararauna
Psittacidae Ara chloroptera
And also show line(s) after the one that was matched, we can use -A x
, where x
is number of lines to use:
grep -i -w -A 1 ara spawannxs.txt
Psittacidae Ara macao
--
Psittacidae Ara ararauna
Psittacidae Ara chloroptera
Psittacidae Arao manilata
Similarly, -B shows the lines before:
grep -i -w -B 1 ara spawannxs.txt
Psittacidae Amazona vittata
Psittacidae Ara macao
--
Psittacidae Amazona ochrocephala
Psittacidae Ara ararauna
Psittacidae Ara chloroptera
Use -n to show the line number of the match:
grep -i -w -n ara spawannxs.txt
216:Psittacidae Ara macao
461:Psittacidae Ara ararauna
462:Psittacidae Ara chloroptera
To print all the lines that do not match a pattern, use -v:
Also try grep -i -w -v ara spawannxs.txt
This will produce a lot of output (which I will not show)! What does this command do?
To match one of several strings, use grep"string1\|string2” file
. grep
can be used on multiple files, all files, using wildcards for filenames, etc – explore as and when you need.
Finding files#
It’s easy to find files in UNIX using, well, the find
command! Let’s test it (make sure you are in Sandbox
, not Data
!)
cd ../sandbox # again, note the relative path!
mkdir TestFind
cd TestFind
mkdir -p Dir1/Dir11/Dir111 #what does -p do?
mkdir Dir2
mkdir Dir3
touch Dir1/File1.txt
touch Dir1/File1.csv
touch Dir1/File1.tex
touch Dir2/File2.txt
touch Dir2/file2.csv
touch Dir2/File2.tex
touch Dir1/Dir11/Dir111/File111.txt
touch Dir3/File3.txt
ls
Dir1 Dir2 Dir3
ls Dir1
Dir11 File1.csv File1.tex File1.txt
ls Dir* # the asterisk wildcards names so you can find all dirs with a particular start to their name
Dir1:
Dir11 File1.csv File1.tex File1.txt
Dir2:
file2.csv File2.tex File2.txt
Dir3:
File3.txt
Don’t forget to use man
to check what mkdir
and touch
do.
Now find particular files:
find . -name "File1.txt"
./Dir1/File1.txt
Using -iname
ignores case, and you can use wildcards:
find . -iname "fi*.txt"
./Dir1/File1.txt
./Dir1/Dir11/Dir111/File111.txt
./Dir3/File3.txt
./Dir2/File2.txt
You can limit the search to exclude sub-directories:
find . -maxdepth 2 -name "*.txt"
./Dir1/File1.txt
./Dir3/File3.txt
./Dir2/File2.txt
You can exclude certain files:
find . -maxdepth 2 -not -name "*.txt"
.
./Dir1
./Dir1/File1.tex
./Dir1/File1.csv
./Dir1/Dir11
./Dir3
./Dir2
./Dir2/File2.tex
./Dir2/file2.csv
To find only directories:
find . -type d -iname *dir*
./Dir1
./Dir1/Dir11
./Dir1/Dir11/Dir111
./Dir3
./Dir2
Installing or removing software in Ubuntu#
You can install software in your /home
directory. In UNIX you originally had to login as root
(administrator). But in Ubuntu, it is sufficient to add sudo
(s
uper u
ser do
) in front of a command. To install packages in all Debian (including Ubuntu) distributions you need to use the apt
group of commands which allow you to deal with various installation (and un-installation) tasks.
Installing from the main repository#
You can install anything that is in the main Ubuntu package/software repository.
★ Try installing R, which is pre-packaged the main Ubuntu repository:
sudo apt install r-base
This will prompt you for your password.
Tip
Using the tab
key in terminal: Don’t forget to use the tab
key in the terminal. It aut-ocompletes directory/file names for you (same in R
and Python
, and/or provides a list of files in the current directory (hit tab
twice after certain commands. For example, try double tab after typing ls
at the bash prompt.)
Enabling additional repositories#
You can enable additonal repositories that are already present (but not enabled by default) by using the Ubuntu “Software Centre” GUI. Launch Ubuntu Software Centre, and then Edit > Software Sources > Other Software (the exact approach will vary depnding on your Debian or Ubuntu distribution).
Installing from other repositories#
In addition there are other repositories you can access, but which first need to be auhtenticated locally for your system’s security and stability. There are typically available in the form of Personal Package Archives (PPAs). The general approach is:
Find the repository’s web page (it’s Launchpad page)
Look for “Adding this PPA to your system” on the page. Make a note of the PPA’s location, which has the format ppa:user/ppa-name.
Open a terminal and enter:
sudo add-apt-repository ppa:user/ppa-name
. (replace ‘ppa:user/ppa-name’ with the PPA’s location that you noted above)
Your system will now fetch the PPA’s key. This enables your system to verify that the packages in the PPA have not been interfered with since they were built.
Finally, download the latest list of software from each repository archive on your system (all of them: main, additional, and extra ones you have added manually such as the PPA you just added. To do this, use:
sudo apt-get update
You can now start installing software from the new repository.
★ Try installing something that isn’t in the main repository – a weather indicator.
For this, you first have to add the repository:
sudo add-apt-repository ppa:atareao/atareao
This will ask you to first approve the addition of this repository. Then, sudo apt-get update
, and then, finally,
sudo apt install my-weather-indicator
Tip
Ubuntu repositories: Official Repositories are defined in /etc/apt/sources.list
. You can enable or disable individual repositories by editing that file.
Installing from downloaded *.deb
files#
You can also install software from third-party sources by downloading an installable package archive. Such archives come with a *.deb
extension.
For example, you can install Visual Studio Code this way. Let’s try it.
★ First download and install the .deb package (64-bit) from their website (google it!). This will save it to your Downloads
directory.Then cd
to its location:
cd ~/Downloads
This is same as typing cd /home/<YourUserName>/Downloads
. Then, you can install using:
sudo dpkg -i code_1.71.2-1663191218_amd64.deb # install, including dependencies
Installing the .deb
package will automatically also install the softwarre’s apt repository and authorize it. That means henceforth, the program code
will automatically auto-update during the regular system updates.
Removing software#
You can also easily remove software by, well, using the remove
command!
You will find that the list of UNIX commands are quite exhaustive, and their names quite intuitive, as they should be. If you think a certain command with a certain name should exist, it very often does!
★ Try removing the totem video player and installing the more versatile VLC player instead:
sudo apt remove totem
and then,
sudo apt install vlc
Particularly useful UNIX tools#
That’s it for our introduction to UNIX. We have just scratched the surface, but hopefully you have seen the potential for using the the UNIX/Linux terminal in particular for performing important tasks efficiently. UNIX has an incredibly wide array of commandline tools that can make your life easier. Here is a list of particularly useful commands (that often belong to a bigger toolkit; some of these will have to be installed using apt
as you have learned above):
Tool |
What it does |
|---|---|
|
Find which processes are using your memory and cpu |
|
Kill processes (use with caution) |
|
Find patterns in directory and file names, as well as file contents; really useful for combining with other tools to perform operations on specific subsets of files and directories |
|
Find files and directories |
|
Convert between document formats (e.g., \LaTeX and Word or Markdown and PDF) |
|
Convert between file |
|
Manipulate PDF files, like merging multple ones or splitting them |
|
Download files from the web |
|
Sync folders on your computer, including on any atatched devices (like an external hard drive) |
|
Set up automated tasks (like run a backup script based on |
|
Keep multiple computers synced |
You will next learn to automate the use of such tools using shell scripts.
To find out more about these commands and tools, look at their man
pages. You can also use whatis
for a brief description, or--help
after the command for usage syntax.
An of course, you can use the internet to get help on practically everything about UNIX – there is huge (and fast growing) community out there.
Practicals#
Instructions#
Review (especially if you got lost along the way) and make sure you can run and understand all the commands and get the expected outputs we have covered above.
Make sure you have your directory organized with
code
,data
etc and the necessary files, under your coursework directory (e.g.,CMEECourseWork/week1
).Along with the completeness of the practicals/exercises themselves, you will be marked on the basis of how complete and well-organized your directory structure and content is – in all coming weeks as well.
Please put (judicious) comments in all of your script files.
Bash command challenge#
Here is a somewhat complicated bash command using two pipes (you are not expected to include the answer to this one as part of your weekly submission):
find . -type f -exec ls -s {} \; | sort -n | head -10
What does this command do? (Hint: try it on the test directories and files we created in sandbox
)
FASTA exercise#
In the directory /data/fasta
you will find some FASTA files. These files have an header starting with >
followed by the name of the sequence and other metadata. The sequence data start from the second line. Write a file called UnixPrac1.txt
with UNIX shell commands that do the following (number each command with a hashed comment like so – #1
, #2
, etc):
Count how many lines there are in each file
Print everything starting from the second line for the
E. coli
genomeCount the sequence length of this genome
Count the matches of a particular sequence, “ATGC” in the genome of E. coli (hint: Start by removing the first line and removing newline characters)
Compute the AT/GC ratio. That is, the (A+T)/(G+C) ratio (as a single number). This is a summary measure of base composition of double-stranded DNA. DNA from different organisms and lineages has different ratios of the A-to-T and G-to-C base pairs (google “Chargaff’s rule”). For example, DNA from organisms that live in hot springs have a higher GC content, the GC base pair is more thermally stable.
Note that there may be some Y
and R
’s in DNA sequences, denoting bases where there is uncertainty about identity, with R denoting purine (A or G) and Y pyrimidine (C or T) ribonucleotides. No agreed symbols exist for the other possible combinations, but these too may arbitrarily be reprsented by some non ATGC letters. To handle these, the calculation should be done by keeping these extra letters in place. That is, do not delete them before calculating the ratio, as this will shift the sequences.
Save
UnixPrac1.txt
in thecode
directory.Please make sure that each command calls the data from the
data
directory!
Do not write any of the above as shell scripts (that’s not been covered yet; see Shell Scripting Chapter – each answer should be a single line solution made of (potentially piped together) UNIX commands.
Readings & Resources#
Your University library likely gives you access to several e- and paper books on UNIX, some specific to Ubuntu. Browse or search and find a intro book that suits you.
General#
If you like history, see this.
Lots of UNIX tutorials out there. Try http://software-carpentry.org/lessons.html (Chapter “shell”).
The bash reference manual: https://www.gnu.org/software/bash/manual/bash.html
Repositories and packages in Ubuntu#
Read about Apt authentication in Debian Linux distributions (including Ubuntu).


Javascript Language
Bracket Notation
Round Brackets ()
There are a few serperate areas where round brakcets crop up.
They can be used for loops to hold true/false statements i.e.
if(n<5)
. In other loops they can have initial conditions and
iteration steps as well i.e.
for (var n=0, n<5, n++)
.
In functions they contain the input parameters that the function requires to run like
function carrots (water, soil, seeds){};
. Finally the can be used in the pure
mathematical way to show which operation is prioritised; the following would sum
b
and
c
together before subtracting the total from
a
:
x = a - (b + c);
Square Brackets[]
Square brackets are often seen setting up arrays and accessing elements in those arrays like numbers or objects. Arrays are
a structured data format so every element has a fixed position where the first element is denoted as
Array[0]
and the sequential elements are counted up from there so that
nth element = Array[n-1]
.
Curly Brackets{}
Curly brackets are used to contain processes that need to be run or to set up objects. For containg
processes take a
for
loop. Everything that needs to be run according to the loops instructions happens within
the defined curly brackets.
For example
for (var i=0, i<10, i++){count++}
increases the
count
by one while the loop conditions remain true.
For setting up objects a new variable is declared with the properties of the object (once the curly brackets get involved the variable becomes
an object) listed within the curly brackets. This
tree
is an example object:
var tree = {branches: 100, leaves: 1000, trunk: 1};


Available substitute fields:
%CONFERENCE_NAME%: Conference name
%CONFERENCE_EMAIL%: Conference e-mail contact address
%SPEAKER%: Speaker name
%SPEAKER_BIO%: Speaker bio
%SUBMISSION_TITLE%: Title of submission
Other fields: %SHORT_SYNOPSIS%, %LONG_SYNOPSIS%, %SUBMISSION_TRACK%, %SUBMISSION_FORMAT%, %SUBMISSION_DURATION%.
Special URLs:


We have metrics!
- implement best-of-breed functionalities
- syndicate virtual eyeballs
- strategize front-end relationships
- orchestrate clicks-and-mortar e-markets
- utilize leading-edge channels
- transform turn-key content
- grow mission-critical vortals
- e-enable mission-critical synergies
- reinvent cross-media functionalities
- transition vertical interfaces
- transform seamless e-tailers


Player 1 (
)
Player 2 (
)
< L
R >
Play again
To move, use the left/right buttons on your keyboard, also you can use the L/R buttons


My name is Bilal I'm passionate about technology, traveling and DIY. Welcome to my website. I've been in the tech industry for more than 8 years and have worked on various projects. I write tutorials on my website, mostly about Linux servers.
What I doBack-up, high availability and flexibility.
Automation and scheduled jobs in BASH, Powershell and PHP.
Database management.
Opensource
I like to think that I'm fairly approachable, I usually respond within a few days. Contact me through:


{{$index+1}}
Unsupported resolution
Resolution below 1024px is not supported, please switch to a higher resolution display.


Take the busy work out of Node.js! Learn how to build modern Node-driven applications using Hapi.js, a flexible, frustration-free, configuration-centric framework.
Get half off the MEAP eBook or MEAP pBook. Use this same code to save 50% on Sails.js in Action and Building the Web of Things.


Hi there! Do you want to create a perlin noise? Then read this tutorial to learn it.
Start by creating a new javascript file. I will be using p5.js library for rendering the noise texture.
Steps:
Start by creating a new array permutation
that contains random numbers from 0 to 255. We will use this as a hashing table.
var permutation = [];
for(var i=0; i<256; i++){
permutation[i] = i;
}
var j, temp;
var m = permutation.length;
while(m){
j = Math.floor(Math.random() * m--);
temp = permutation[m];
permutation[m] = permutation[j];
permutation[j] = temp;
}
Create an empty array, then fill it witth numbers from 0 to 255; Shuffle all the numbers inside that array.
After that part create an empty array called p
This would serve as a hash table later.
var p = [];
for(var x=0; x<512; x++){
p[x] = permutation[x % 256];
}
Now after that create the main perlin
function. The function would accept x, y and z and returns a float between 0 and 1.
function perlin(x, y, z){
}
Inside the perlin function create xi, yi, and zi
. Normalize the x, y and z
using the binary & operator and a number 255.
var xi = Math.floor(x) & 255;
var yi = Math.floor(y) & 255;
var zi = Math.floor(z) & 255;
Continuing with that create xf, yf and zf
. Get the difference between the coordinates and the floored coordinates
var xf = x - Math.floor(x);
var yf = y - Math.floor(y);
var zf = z - Math.floor(z);
Outside the perlin function, create a new function called fade
. It uses a polynomial 6t^5 - 15t^4 + 10t^3
to evaluate a given float.
function fade(t){
return t * t * t *( t * ( t * 6 - 15) + 10);
}
Continuing inside perlin function, create u, v and w
. Use the newly created hash
function for xf, yf and zf
.
var u = fade(xf);
var v = fade(yf);
var w = fade(zf);
Now create aaa, aba, aab, abb, baa, bba, bab, bbb
This represent the 8 corners off the cube. This is where we will use are p
hash table
var aaa, aba, aab, abb, baa, bba, bab, bbb;
aaa = p[p[p[ xi]+ yi]+ zi];
aba = p[p[p[ xi]+yi+1]+ zi];
aab = p[p[p[ xi]+ yi]+zi+1];
abb = p[p[p[ xi]+yi+1]+zi+1];
baa = p[p[p[xi+1]+ yi]+ zi];
bba = p[p[p[xi+1]+yi+1]+ zi];
bab = p[p[p[xi+1]+ yi]+zi+1];
bbb = p[p[p[xi+1]+yi+1]+zi+1];
Outside the perlin
function, create a new function called grad
and hash
. You will use grad
for returning values from one of the corners of the cube and lerp
for linear interpolation.
function lerp(a, b, x){
return (b - a) * x + a
}
function grad(hash, x, y, z){
switch(hash & 0xF){
case 0x0 : return x + y; break;
case 0x1 : return -x + y; break;
case 0x2 : return x - y; break;
case 0x3 : return -x - y; break;
case 0x4 : return x + z; break;
case 0x5 : return -x + z; break;
case 0x6 : return x - z; break;
case 0x7 : return -x - z; break;
case 0x8 : return y + z; break;
case 0x9 : return -y + z; break;
case 0xA : return y - z; break;
case 0xB : return -y - z; break;
case 0xC : return y + x; break;
case 0xD : return -y + z; break;
case 0xE : return y - x; break;
case 0xF : return -y - z; break;
default: return 0;
}
}
Finally, inside the perlin
function, create x1, x2, and y1, and y2
. You will linear interpolate the floats. Lastly the perlin
function will return a float between 0 and 1!
var x1, x2, y1, y2;
x1 = lerp(grad(aaa, xf, yf, zf),grad(baa, xf-1, yf, zf),u);
x2 = lerp(grad(aba, xf, yf-1, zf),grad(bba, xf-1, yf-1, zf),u);
y1 = lerp(x1, x2, u);
x1 = lerp(grad(aab, xf, yf, zf-1),grad(bab, xf-1, yf, zf-1),u);
x2 = lerp(grad(abb, xf, yf-1, zf-1),grad(bbb, xf-1, yf-1, zf-1),u);
y2 = lerp(x1, x2, v);
return ( lerp(y1, y2, w) + 1)/2
Create a new function pNoise
if you want to get a better noise results. I know you'll copy this. Copy it all!
function pNoise(x,y,z,o,p){
y = y || 0.99;
z = z || 0.99;
o = o || 6;
p = p || 0.35;
var total = 0;
var frequency = 2;
var amplitude = 5;
var maxValue = 0;
for(var i = 0; i < o; i++){
total += perlin(x*frequency, y*frequency, z*frequency) * amplitude;
maxValue += amplitude;
amplitude *= p;
frequency *= 2;
}
return (total / maxValue);
}
Note: o
is the octave and p
is the persistence.
Here's a real demo: I hope you like it!


xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx x x x ASCII BIRDS x x x x How to play: x x - Flap your wings to move! x x [ SPACE ]. [ ` ] or [ 0 ] to rest x x [ 1 ], [ 2 ], [ 3 ], [ 4 ] to flap x x - Fly out of bounds and you're done! x x - Don't hit a pillar! x x - Earn points with skill, daring maneuvers, and no small helping of luck! x x - Need a little guidance? Plot your course by hovering over x x the movement buttons at the bottom of the screen! x x ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~x x x x Other instructions: x x x x [ SPACE ] or [ n ] to start a new game x x [ q ] to quit x x x x [ ? ] to open this help window x x [ Esc ] to close this help window x x x xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx


Photo Story
Homeless on the Home Front
> Explore the feature
Interactive Feature
Major candidate tax proposals
> Explore the feature
Data Visualization
Financing Public Higher Education
> Explore the feature
Data Visualization
How to Reduce the Federal Prison Population
> Explore the feature
Data Visualization
Where Are the Unbanked and Underbanked in New York City?
> Explore the feature
Interactive Feature
Our Changing City
> Explore the feature
Long-form
In Search of a New Path: Can Holistic Prisoner Reentry Work on the West Side of Chicago?
> Explore the feature
Interactive Map
How Immigrants Are Reshaping Residential Segregation
> Explore the feature
Interactive Feature
Rent Burden High in Low- and High-Cost Metros Alike
> Explore the feature
Interactive Feature
Stepping Up: How Cities Are Working to Keep America's Poorest Families Housed
> Explore the feature
Interactive Feature
A closer look at income and race concentration in public schools
> Explore the feature
Data Visualization
State Economic Monitor
> Explore the feature
Interactive Feature
Who’s afraid of the Form 1040?
> Explore the feature
Data Visualization
ACA Marketplaces Make Significant Progress in 2015
> Explore the feature
Data Visualization
Nine Charts about Wealth Inequality in America
> Explore the feature
Data Visualization
Mapping America's Futures
> Explore the feature


## The ABC of WWW
#### In today's highly commercialised web of multinational corporations, proprietary applications, read-only devices, search algorithms, Content Management Systems, WYSIWYG editors, and digital publishers it becomes an increasingly radical act to hand-code and self-publish experimental web art and writing projects. J.R. Carpenter, [A Handmade Web](http://luckysoap.com/statements/handmadeweb.html), 2015
Even if you’re not going to develop your own websites, it’s useful to understand how a website is made. It will give you insight into the process and build a better base of understanding when collaborate with developers. Maybe you’ll also enjoy it!
This week we'll be going through how to create a simple website: - What a website essentially is - What tools you need to start building - How to choose and buy a domain name - Where you can host your site - A little bit on GitHub and version control - The basics of HTML - Where you can learn more or ask for help - How to inspect and critically analyse websites
### Using off-the-shelf services like [Cargo](https://cargo.site/) vs hand-coding your own
It's more important to think about the _why_. What does digital publishing offer that other mediums don’t? Which audiences are you trying to reach? What are you trying to say?
Web development can seem really intimidating when you’re just starting out. There's all these new frameworks, best practices – it's hard to keep up.
However, the fundamentals of the web are actually [pretty simple](http://motherfuckingwebsite.com/).
There are also lots of places online where you can learn to code or look for help when you’re stuck. If you know the basics of how it all works, and can describe your problem in words, you're halfway there.
It all boils down to the content: digital publishing is just another medium for communication.
You have HTML for structuring content, CSS for styling it…
Simple websites are more resilient, faster and more accessible – you can take them apart and look at the pieces.
Complex, JavaScript-heavy websites make all kinds of assumptions about their users.
Super fast Internet connection Browsing on desktop English-speaking Fully-sighted, able-bodied Technically savvy
## So what is a website?
At its most basic, the Internet is a large network of computers which communicate all together. The Internet is an infrastructure, whereas the Web is a service built on top of the infrastructure.

Diagram by [Minkyoung Kim](http://minkyoungkim.com/teaching/gdfws19/)
To access those files, you need to know their address. Humans find information online through domain names, while web browsers interact through IP addresses.
### IP: Internet Protocol A string of numbers that uniquely identifies your site. You can look up a website's IP address at [https://ipinfo.info/html/ip_checker.php](https://ipinfo.info/html/ip_checker.php)
### DNS: Domain Name System The phonebook of the Internet. DNS translates domain names to IP addresses so browsers can load Internet resources.
### URL: Uniform Resource Locator
### URL: Uniform Resource Locator
### Buying domain names [gandi.net](https://www.gandi.net/en-GB) and [hover.com](https://www.hover.com/) are some good domain name registrars.
### Interlude: Every TLD has a story [Domain Stories](http://citizen-ex.com/stories) by James Bridle
### Where should your website live on your computer? When you are working on a website locally on your computer, you should keep all the related files in a single folder that mirrors the published website's file structure on the server.
### File names Many computers, particularly web servers, are case-sensitive. For example, if you put an image on your website at, `test-site/MyImage.jpg` and then in a different file you try to invoke the image as `test-site/myimage.jpg`, it may not work.
### File names They also don't handle spaces consistently, so it's safest to seperate words with dashes, e.g. `my-file.html`.
### Folder structure
### File paths
### Relative file paths Down a directory: `subdirectory/example.jpg` Up a directory: `../example.jpg`
### Publishing a website As well as buying a domain name, you'll need somewhere to host your website. If you're not using a service like Cargo, you'll need to buy your own hosting.
### Hosting a website [nearlyfreespeech.net](https://www.nearlyfreespeech.net/) is a cheap hosting service. You'll need to use FTP to transfer your files to their server.
### FTP: File Transfer Protocol Some good ones are [Filezilla](https://filezilla-project.org/) (free) or [Transmit](https://panic.com/transmit/) ($45).
### Publishing a website Once you've uploaded your files to the server, you'll need to update your domain's DNS settings to point it to the right place.
### GitHub Pages Otherwise, you can host a site directly from a GitHub repository for free with [GitHub Pages](https://pages.github.com/).
### GitHub A code hosting platform for version control and collaboration. It's built on Git, a version control system.
Diagram from [Save your Code Revisions Forever with Git](https://github.com/Rafase282/My-FreeCodeCamp-Code/wiki/Lesson-Save-your-Code-Revisions-Forever-with-Git)
### Online code editors [Codepen](https://codepen.io/) allows you to edit and render code directly from the browser. You can use it for sharing code and debugging.
## HTML: HyperText Markup Language
### HTML = Structure ### CSS = Style ### JavaScript = Behaviour
### HTML attributes HTML attributes are modifiers of HTML elements. They give specific directives to HTML elements and are located inside of opening tags.
### HTML attributes One element can have multiple attibutes. `
home
`
### Empty elements You can also have empty elements (without a closing tag). `
`
It's a very resilient language – browsers will always be able to show you something, even if it's broken.
### Anatomy of an HTML file
`` Tells the browser what kind of document it's looking at
`` Wraps all the content in the page
`` All the stuff that _isn't_ your content, like metadata and links to stylesheets
`
` Defines the character set, UTF-8, which includes most characters from the vast majority of written languages
`` Everything else
### Semantic HTML
### Semantic HTML Search engines Screen readers Easier to find elements when you're coding
### What elements best describe the content? Is it a list of data? Ordered, unordered? An article with sections and an aside of related information? Is it a figure or image that needs a caption? Should it have a header and a footer?
### Resources [All HTML elements](https://developer.mozilla.org/en-US/docs/Web/HTML/Element) [Getting to Know HTML](https://learn.shayhowe.com/html-css/getting-to-know-html/) [HTML Essential Training](https://www.lynda.com/Web-Development-tutorials/HTML-Essential-Training/170427-2.html) [Introduction to HTML](https://www.codecademy.com/learn/learn-html) [Foundation HTML, CSS + Javascript](https://www.superhi.com/courses/html-css-javascript-foundation) [Structuring the web with HTML](https://developer.mozilla.org/en-US/docs/Learn/HTML) [Semantic HTML](https://internetingishard.com/html-and-css/semantic-html/)
### Looking for help [Stack Overflow](https://stackoverflow.com/)
## How to set up a GitHub Pages site
### Getting started - Web browser with developer tools: [Google Chrome](https://www.google.com/chrome/) - Text editor: [Atom](https://atom.io/) or [Sublime Text](https://www.sublimetext.com/)
### Step 0 Sign up for an account on [GitHub](https://github.com/). Download [Github Desktop](https://desktop.github.com/) application and install it on your local computer.
### Step 1 Create a new repository named `username.github.io`, where `username` is your GitHub username.
### Step 2 Clone the repository by clicking the "Set up in Desktop" button.
### Step 3 Open your text editor and create a new file called `index.html`.
### Commit On GitHub, saved changes are called commits. Each commit has an associated commit message, which is a description explaining why a particular change was made. Commit messages capture the history of your changes, so other contributors can understand what you’ve done and why.
### Step 4 Commit your changes and press publish.
### Step 5 Open your browser and go to `username.github.io`.
### Hyperlinks [Everything Easy is Hard Again](https://frankchimero.com/writing/everything-easy-is-hard-again/) [Why GOV.UK content should be published in HTML and not PDF](https://gds.blog.gov.uk/2018/07/16/why-gov-uk-content-should-be-published-in-html-and-not-pdf/) [Resilient Web Design](https://resilientwebdesign.com/)


val paymentMethodCard: Card?
A PaymentMethodCreateParams.Card representing the card details if all fields are valid; otherwise null
null


enum class NotifyBotStateModifier
(source)
Manage bot state and notifications.
KEEP_CURRENT_STATE |
If the bot is disabled for the user, don't send the notification. |
ACTIVATE_ONLY_FOR_THIS_NOTIFICATION |
Send the notification even for disabled bot, but don't reactivate the bot for the user if it is disabled. |
REACTIVATE |
Send the notification and reactivate the bot for the user. |


We humbly believe that we host a successful event for our vendors so they always leave happy. In 2016 we had an estimated 10,000 guests. Even with inclement weather we have drawn nearly 4000 guests.
Pay application fee online after approval.
Guilds are groups of people that come to the faire for free because they bring something special or exceptional to our event. Guilds are expected to be a full part of the renfaire family. You must have costumes. We want a guild to be able to contribute in some way to the event and here are some things that we are looking for: Royal courts from the around the world, such as Vikings, Italian, Celtic, Spaniards, and Far Eastern. We are also looking for guilds such as, yeoman of the guard, gentlemen adventurers, towne criers, cooks, jesters, dance groups such as dance macabre, puritans, mongers, mercenaries, and equestrians.
We welcome new and creative guild ideas!
The entertainment is an integral part of the Utah Renaissance Faire. We love our entertainers and we are always looking for new individuals or groups that can keep our guests amazed. If you feel like this is you please contact us!
The artisans are another reason our faire is so great. As an artisan you are there to educate, inspire, and enlighten our guests. Artians are usally people like blacksmiths, weavers, luthiers, carpenters, soap makers, bakers, etc. This is not the same thing as a vendor because your primary reason for coming to the event is not to be selling merchandise or goods.
We are always looking for people to help us throughout the year with planning the event, helping us improve, and raising awareness. In addition, we welcome volunteers for the days of the event. Please let us know your availablity in the form through the link below.


{{ partial "header.html" .}} {{ partial "new-header.html" .}}
Looks like you don't have permission to access that. Try the top menu for additional options, or if you think you should have access, email me.


1. NTUA considers it very important that the data of visitors to the WITH website be handled with due care. Consequently, NTUA website has been designed with a view to protecting your privacy to the greatest degree possible.
2. Except in exceptional circumstances as outlined in the general terms and conditions of use of this website and as allowed by law NTUA will not supply your personal data to third parties without obtaining your express consent. The personal data that you supply shall only be used in connection with your use of this website and content.
3. NTUA does not collect names, addresses, telephone numbers or other personal data, unless this information is provided voluntarily by visitors to this website and in connection with your use of the content on this site. Your personal data are not visible on the website.


Knockin’ On Heaven’s Door
Fate brings the heroes of the picture in the hospital, where the doctors impose a death sentence on them. The time of their lives is on the clock. Further events in the film unfold at a rapid pace. After stealing a car with a million German marks in the trunk, they escape from the hospital. They are pursued by assassins, they become involuntary robbers, they are chased by the police, they get into a brothel. But nevertheless continue to rush forward, towards the destiny.


{% extends "base.html" %} {% block content %}
FeedThing is a personal, web-based feed reader. It is open source and written in Python/Django.
Find out more.


{% extends "admin_layout.html" %} {% block page_header %}
All our digital services must be accessible and meet WCAG 2.1 guidelines. This section does not replace these guidelines, which provide a full explanation of all principles and requirements.
Our services must also allow people who may not have the skills or access to use them online. This is called assisted digital.
[TK]


I'm a software developer with a strong background in computer science.
I have immense experience in research and data analysis, data mining,
machine learning, video editing and also graphic design.
I always strive to deliver solutions to my client's
problems and create mobile applications that are user tailored to
give the best experience and exceptional services.
PERSONAL DETAILS
Date of birth:
Nationality:
P.O.BOX:
Marital Status:
18/8/1998
Kenyan
75104-00200
Single
EDUCATION
Relevant Coursework:Mathematics; English; Biology; Physics; Chemistry; Business Studies.
Overall Grade A- 76/84 points
African Leadership University
Kigali,Rwanda: 09/2018 - 2022
BSc.Computer Science:
Programming ; Discrete Mathematics; Database Systems; Mathematical Computing.
Tools: SQL, HTML, JavaScript, C, C++
Moringa School
Nairobi,Kenya: 10/2019 - 04/2020
Data Science:
Key Coursework: Business understanding, Data Understanding, Data Preparation, Data Analysis, Data Visualization and Machine Learning
Logic for Data Science(Python programming, SQL programming, Project Management with Jira)
Tools: Python, Numpy, SQL, MySQL, Postgres, Git, Github, Jira, Pandas, Matplotlib, Tableau, Tensor-flow
HONORS AND AWARDS
- Best Chess Player/ Medal and Certificate, Lenana School, 2015.
- Exemplary performance/Wooden medal and Certificate, Lenana School, 2015.
- Basketball/Certificate, Lenana School, 2014.
SKILLS
Technology : Programming in Java, Python, Experienced in Microsoft Office Suite; Linux
Languages : English (fluent/native), Kiswahili (fluent/conversational), Kinyarwanda (Beginner)
Project Management, Public Speaking, Market Segmentation.
EXPERIENCE
Borgen Project(Telecommute) - Human Resource Intern
Seattle, USA, 2/2018 to present
- Interviewed and made hiring decisions on a candidate’s application
- Formulated both interview and exit survey questions for the organization
- Managed over 1000 candidate applications
- Posted internship opportunities to university career websites
- Helped fundraise over $500 that was used to support those in need in developing countries. link
African Leadership University- Student Recruitment
Kigali, Rwanda, 01/2018 to 05/2018
- Addressed students, parents, educators and other stakeholders about the undergraduate program and ALU experience.
- carried out campus tours for visitors.
- Helped current applicants with queries on the ALU undergraduate application.
- Worked on projects to improve student recruitment processes and systems.
Equity Bank Head Office - Corporate Management & SME Banking
Nairobi, Kenya, 06/2017 to 09/2017
- On boarded and trained over 500 corporate clients and companies on how to use the EazzyBiz, bank’s online transaction platform.
- Identified a bottleneck in the on-boarding system and made recommendations which refined the process by making it 4 times faster.
Alexander Forbes - Ops & Admin
Nairobi, Kenya, 12/2016 to 03/2017
- Calculated and managed over 1000 pension claims.
- Advised and registered over 2000 new clients on to the system.
Equity Bank - Relationship Officer
Nairobi, Kenya, 04/2016 to 09/2017
- Worked with two other interns under a Marketing team to onboard and distributed over 3000 Equitel lines to customers
- Created an interview guide and online survey on how to improve customer experience, interviewing 40 customers and collecting 130 surveys. With the findings, we were able to promote customer experience
and the number of customers and more positive feedback in social media
VOLUNTEER
Innovate Kenya (gmin.org) - Recruitment Officer
Nairobi, Kenya, 02/2016 to 08/2016
- Simplified the recruitment process of schools, tripling the number of the given target. The position empowered me with communication skills, leadership skills, teamwork, and event planning and budgeting


Nobody gives away free xbox online. Be careful with this kinds of offers as they will try to obtain your card information or even infect you with a digital virus


By: billyzhang2010 原文发布于：2010-07-12 22:34:11
GTD® is the popular shorthand for "Getting Things Done®", the groundbreaking work-life management system and book by David Allen that transforms personal overwhelm and overload into an integrated system of stress-free productivity.
Piloting a productivity seminar for a thousand managers at Lockheed in 1983, David has continued to test and refine the techniques and principles we now know as GTD - a powerful method to manage commitments, information, and communication. This pioneering and proven system is the result of those twenty plus years of David's consulting, private coaching and organizational programs with over a half million people internationally. GTD has well earned its recognition as the gold standard in personal management and productivity for many of the world's best and brightest people and companies.
Sophisticated without being confining, the subtle effectiveness of GTD lies in its radically common sense notion that with a complete and current inventory of all your commitments, organized and reviewed in a systematic way, you can focus clearly, view your world from optimal angles and make trusted choices about what to do (and not do) at any moment. GTD embodies an easy, step-by-step and highly efficient method for achieving this relaxed, productive state. It includes:
Implementing GTD alleviates the feeling of overwhelm, instills confidence, and releases a flood of creative energy. It provides structure without constraint, managing details with maximum flexibility. The system rigorously adheres to the core principles of productivity, while allowing tremendous freedom in the "how." The only "right" way to do GTD is getting meaningful things done with truly the least amount of invested attention and energy. Coaching thousands of people, where they work, about their work, has informed the GTD method with the best practices of how to work (and live), in that most efficient and productive way.
GTD's simplicity, flexibility, and immediacy are its attraction. Its ability to enliven, enlighten, and empower is its magic. What, indeed, is GTD? More than meets the eye...


A portal
gives you the ability to "teleport" a template to a different part of the UI while keeping its context where
it is defined. It is similar to content projection, only much more dynamic. You are not bound to render it as
a child of the component you want to render the template into, rather you can render it anywhere in the UI
that you want.
The Portal mechanism is done with the help of two directives: goPortalAttachTo
and
goPortalTarget
. Both directives take a string binding that is used to
connect the two templates. The strings must match in order for the portal to work.
Apply the goPortalAttachTo
directive to the template that you want to "port", and the goPortalTarget
directive on the destination where you want the "ported" template to render into.
Specify the template for the goPortalAttachTo
directive.
Then, specify the destination via the goPortalTarget
directive.
The first template will render in the place that the second template is declared.


Mister Scrimgeour's Aviary
Last Tuesday, Mr Scrimgeour realised his lifelong ambition. Five hundred yards to the south of the Pang Hill Orphanage, he threw open the gates of his aviary. The tots had been gathered outside for three hours, the tinier ones literally wetting themselves with excitement.
Mr Scrimgeour had announced the opening of his aviary only the day before, but work had been going on for months, if not years. The parentless infants had grown used to the sight, from the orphanage windows, of a gigantic fence of corrugated iron. Suddenly, overnight, it was gone, the outer walls of the aviary visible at last. As they ate their breakfast porridge, they were told that they would be the very first visitors. Mr Scrimgeour did not even want to be paid.
And now, at noon, they marched solemnly in, their excitement replaced by awe. At first, there were no birds to be seen. Beyond the main gate, at the end of a muddy pathway, were two further gates: huge, of beaten bronze, and each with a sign upon it, a single word, black on white, in letters so plain and clear that even the most myopic infant could read them, if they could read at all, and many of them could not, because the Pang Hill Orphanage was a notoriously ill-run institution, the principal an unscrupulous ex-mariner who picked his staff from wretched sinks of iniquity down by the docks. Between the gates stood Mr Scrimgeour, wearing a peculiarly dainty hat.
"Hello, hello, oh hello children!" he cried, his jollity somewhat forced. "You must come and see my birds! But you must choose. You may only enter through one gate. On one side, you will find cages containing specimens of all the birds that the Bible says are clean. And on the other, the birds that the Bible says are unclean. The choice is yours!"
The poor little Godless tinies looked at each other, and at Mr Scrimgeour, and at the gates. Whatever may lie behind them, the gates themselves were identical - neither glistening and shiny nor stained and splattered with muck. They did not know that behind one gate they would find turtle doves, pigeons, quails, sparrows, swallows, cocks and hens, partridges and cranes, and that behind the other were eagles, ossifrage, ospreys, vultures, gledes, kites, ravens, owls, great owls, little owls, hawks, nighthawks, cuckoos, cormorants, swans, pelicans, gier eagles, storks, herons, lapwings, bats, ostriches, peacocks and bitterns. The poor little mites had no idea at all, and they could certainly not ask for guidance from the ruffians in whose charge they languished. No doubt, dear reader, you have read your Bible and can run to the orphans' aid, and while you are about it, release the bats!


Gulp and Twig.js
This page is generated by Twig.js using the gulp-twig gulp plugin.
Fast
Flexible
Secure


1. Prepare your data¶
Here we will present you how to configurate the project. Think about installing all the library needed see requirement .
In order to train the RNN you need data. For this project, we use SMILES to represent the molecules.
Your SMILES file have to be in the data_in/ repertory. One SMILES per line.
The currents data files are :
all_smiles : SMILES extracted from the Riken data base:
- 3,346,716 SMILES in all_smiles file (80 Mo)
- 3,042,980 SMILES in all_smiles_unique file (without doubles) (73.2 Mo)
emolecules : SMILES from eMolecules :
- 22,396,732 SMILES in emolecules file (870 Mo)
- 22,165,087 SMILES in emolecules_clean (without SMILES with a dot) (860 Mo)
pubchem : SMILES for PubChemQC
- 90,131,772 SMILES in pubchem file (4.6 Go)
- 76,182,195 SMILES in pubchem_unique file (3.8 Go)
You can use the clean_data function to delete the “.” from the SMILES.


Admin Panel - edit title
*Title:
Display?
*Genre:
*Duration:
Equipment(3d etc):
Producer:
Actors:
Description:
Update
Back