Erik Garrison
University of Tennessee Health Science Center
Workshop on Genomics - Český Krumlov
January 12, 2024

https://evomics.org/wp-content/uploads/2024/01/Variant-calling-Workshop-on-Genomics-2024-Cesky-Krumlov.pdf

Address of the bookmark: https://evomics.org/wp-content/uploads/2024/01/Variant-calling-Workshop-on-Genomics-2024-Cesky-Krumlov.pdf

https://bioinformatics-core-shared-training.github.io/cruk-summer-school-2017/Day1/Session4-seqIntro.html

Address of the bookmark: https://bioinformatics-core-shared-training.github.io/cruk-summer-school-2017/Day1/Session4-seqIntro.html

Address of the bookmark: https://bioinfologics.github.io/post/2018/09/17/k-mer-counting-part-i-introduction/

Prerequisites

This is an intermediate lesson and assumes learners have already done some bioinformatics:

• Familiarity with the BASH command shell, including concepts like pipes, variables and loops.
• Knowledge of bioinformatics fundamentals like the FASTQ file format and transcriptome sequencing, in order to understand the example workflow.

No previous knowledge of Snakemake or workflow systems is required.

https://carpentries-incubator.github.io/snakemake-novice-bioinformatics/index.html

Address of the bookmark: https://carpentries-incubator.github.io/snakemake-novice-bioinformatics/aio/index.html

Starting with your current or most recent employment provide details of your position as follows:

• A chronological CV should be arranged in reverse chronological order. It should be apparent immediately where you are now.
• Remember that an application form is limited to the few things that a particular institution wants to know about everybody. A CV lets you give information that is unique to you. Add all your key accomplishments and activities in the initial draft. In subsequent drafts, you can remove information that may not be pertinent.
• Resist the temptation to append explanatory sentences or language, which will distract the reader from the basic information being presented. The language of a CV is abbreviated and succinct. When applying for residency training, you will have the opportunity to express yourself in a personal or biographical statement. In the future, when applying for a job or some other type of position, you will want to include an appropriate cover letter with your CV to explain your particular qualifications and strengths for the position.
• Don’t despair if your CV doesn’t resemble those of other students who are applying to the same residency program. Everybody’s CV is different. Even if everyone used the same format suggested in this section, your CV will not resemble others’ because it doesn’t have the same content. No residency program director is looking for a specific CV style. You will receive points for neatness, and readability.
• Be honest. If you haven’t accomplished anything in a particular category, leave it out. Don’t create accomplishments to fill in the spaces. You can be specific about your level of participation in a project or activity, but don’t be misleading (i.e., you can say you coordinated membership recruitment for your AMSA chapter, but don’t say you were “president” unless you were).

• Job title - time that you have held this position
• The key tasks and responsibilities that comprise this role's requirements - notable achievements whilst in the role
• Where possible quantify your achievements with precise facts and figures, e.g. managed junior staff, handled department budget, prepared management reports
• Expand on the skills you are using in your current job which you believe will be valuable in the position(s) for which you are applying

It is not necessary to state the reason you are leaving your current position. This will be a topic for conversation when you are invited for interview or can be covered in your letter of application.
For all previous employment, unless one appointment was more significant than your current or last position, keep details brief i.e. the name of the company, job title, period of employment and the job.
Be sure there are no gaps in your career history - unless for example you took a year out to travel, in which case make reference to this under Interests/Hobbies.
If you are a student just starting work, give any evidence you can to demonstrate your practical skills e.g. school prefect, event organisation, member of sports team, contributor to college magazine or voluntary work.

You are under no obligation to disclose marital status, age or whether or not you have children unless these are specific criteria for selection for a position that you are interested in.
Consider what examples (interests/ hobbies) you can give to show that you match the selection criteria.

If they want someone to work as part of a large team, remember to say if you belong to a local organisation or if you are part of a sports team.

If they want someone who will work on their own for large periods of time, make reference to an Open University course you are considering undertaking.

Your primary objective is to convince the prospective employer that you have the requisite skills, experience and hunger to do the job.

Your CV should be no more than two A4 pages and as every employer is different remember to customise your CV to every job you go after.

There are abundant books on the contents and presentation of a general CV. A BMJ article published in 1978, offering doctors guidance on how to prepare a CV, has been reprinted in the widely read How to do it series.1 2 A survey among postgraduate deans and training advisers at regional colleges found that the contents and presentation of a model CV for doctors in training has been published.3 It is perhaps surprising to note that these models differ significantly from one another. Although they may be useful as starting points, their differences tend to create confusion and anxiety among students. I would argue that these differences exist because the content and presentation of the "ideal" CV vary considerably among individual applicants, the stage of their careers, and the purposes for which the CV is used. It is impossible to create a generic CV. I have therefore not attempted to draw up another model CV. Rather, the purpose of this article is to outline the general principles and important practical points in preparing a good CV. General principles on contents Before finalising your CV for a particular purpose you must be sure of your objectives, whether it is used as an initial screening or the only selection instrument, and the criteria against which it is judged. What details, and how many of them, to include in your CV depends on these factors. I shall illustrate with examples relevant to medical students. 

(1) Job application Your objective is to get the job. In a job application, the CV is used for two purposes: as an initial screening instrument for shortlisting candidates and as a framework for discussion during the interview. The explicit criteria used for shortlisting are usually given in the job advertisement. For some organisations, separate lists of essential and desirable criteria are given. Alternatively, you can get a good idea of the basic requirements from the job description. Your CV must clearly highlight these criteria, preferably on the first page. These usually include: formal qualifications; registration with the General Medical Council; and the prescribed experience. It is sometimes easy to forget to mention items specifically asked for in the job description (for example, a valid driving licence). The implicit criteria are less easy to pinpoint. For example, how much detail on your BSc dissertation and publications should you include? Should you make a long list of extracurricular activities, interests outside medicine, and positions of responsibility? If you admit to a wide range of extracurricular activities and interests, would you be considered as a candidate with a well balanced mature personality or will it be interpreted to mean that you will have little time or interest to do your job? There are no easy answers. Common sense might tell you that BSc dissertation and publications are more important in application for teaching hospital or research posts, but less important for district hospital posts. Conversely, you might think that interests outside medicine are more important for posts in district hospitals or in general practice. This is, however, not always true. A few consultants at district hospital are highly academic. Information gathered from students and doctors working under the professor or consultant concerned may be vital. Alternatively, it is worth while doing your homework by looking up your prospective consultant in the medical directory. This may occasionally prompt you to include information that you might otherwise have left out. For example, you may find that the consultant qualified in Scotland and has previously worked in Scotland for a considerable time, and you may decide to add in your CV that you studied in a Scottish secondary school. Since the CV is only used as for initial screening, you need not go into your previous experience or extracurricular activities in too much detail. Highlight only the most significant points, and leave the details for the interview. If you are applying for a clinical post, one of your referees should be a consultant for whom you have worked as a student. You should ask for permission to use his/her name before submitting your application. 

(2) Application for research scholarship or PhD studentship The CV and application form are sometimes used as the sole selection instrument, and you must make enquiries before you submit your application. Clearly, academic ability is the main criterion for selection, and you should include as much information relevant to your academic ability and interests as you can. Examples are your A levels, your BSc dissertation, any publications (even in the form of a letter in newspaper), any experience as an editor (for example, for your school magazine). Your extracurricular activities are less important, and you can simply give a short list. At least one of the referees should be an academic - for example, your previous supervisor in your BSc degree.
 
(3) Application to join a clinical course in another medical school Preclinical students who have completed an intercalated degree often have the option of applying to join a clinical course in another medical school, although it may become more difficult to do so with the introduction of the new GMC curriculum. Your CV is usually used for shortlisting candidates for interview. The criteria differ slightly among medical schools, but both academic ability and contribution to university life are important. Hence, not only should you highlight your academic achievements but you must also highlight your participation in the university (for example, in sports or music). 

(4) For the information of your tutor or counsellor For most medical schools, you are allocated a tutor who provides both academic and non-academic support and monitors your progress throughout your study on a confidential basis. Students are sometimes asked to submit their up to date CV to their tutors for information. Assuming that the tutors are helpful there is little to gain from over emphasising your strengths or hiding your weaknesses. Once you become a doctor in training after you qualify you will need to undergo an annual assessment of your progress. It serves to certify that you have reached a satisfactory standard, but it is also used as an aid to identify and help with your weaknesses. You may find it difficult to balance these two purposes in presenting your CV. General principles on presentation Now that all students are computer literate, there should be few problems in preparing a well presented CV. The following list serves as a reminder on how to present your CV effectively: Spelling or grammar mistakes - do not rely purely on the spell check on your computer. Ask friends to proofread your CV for you. Consistency - The use of punctuation to open and close sentences, justification, and fonts should be consistent. Readability - The headings should be clear. The font size should be no less than 12 point. Basic criteria - The basic criteria should be easily located, preferably on the first page. Length - The length of your CV increases as you progress up the professional ladder. For students, it should generally be no more than three pages. Quality of print - The CV should be printed on good quality paper, preferably using a laser printer. Practical points In this article, I argue that different versions of a CV may be required for different purposes. Even applications for different posts in the same specialty may require slightly different versions. Also, CVs need to be updated regularly. This would have been time consuming to achieve in the past, but it is now quite simple, with the aid of a basic word processing package. A master CV containing all relevant information should be prepared and saved as a computer file. This should be continuously kept up to date. When the need for a CV arises, it can be tailormade by editing the master document. It is important to save each of these edited versions separately, with the file names indicating the date when it was created and the purpose. It is also important to prepare a cover letter to go with the CV. Key messages A good CV is essential for successful progression up the medical professional ladder The contents of the CV should be tailormade for the purpose it is used for and the criteria against which it is judged. It is important to gather information about these criteria first The CV must be technically well presented, with the basic criteria easily located Information technology has made it simple to regularly update our CVs and allows preparation of different versions of a CV for different purposes with relative ease.

Reference:

Prepare a curriculum vitae. BMJ 1978;25(2):1478-9.
O'Brien E. Prepare a curriculum vitae. In: Reece D, ed. 
How to do it. Vol 1. London: BMJ Publishing Group, 1995 Chambler AF, Chapman-Sheath PJ, Pearse MF. 
A model curriculum vitae: what are the trainers looking for? Hosp Med 1998;59(4):324-6.

For further details about the underlying algorithm see the original publication:
MACSE: Multiple Alignment of Coding SEquences accounting for frameshifts and stop codons.
Vincent Ranwez, Sébastien Harispe, Frédéric Delsuc, Emmanuel JP Douzery
PLoS One 2011, 6(9): e22594.

Address of the bookmark: https://bioweb.supagro.inra.fr/macse/index.php?menu=releases

1. 2 Eggs and 100 Floor Classic Puzzle
2. Five pirates and gold coin Puzzle
3. Six pirates and Gold Coin puzzle
4. Probability of having boy
5. Random Airplane Seats
6. Inverted playing card puzzle
7. Flipping Coins Puzzle
8. Three hat colors Microsoft Puzzle
9. 25 horses 5 tracks Puzzle
10. Gold Bar Puzzle
11. Crossing the Bridge Puzzle
12. Will you accept the bet?
13. The Puzzle of 100 Hats
14. Man fell in Well Puzzle
15. Minimum Number of Weigths
16. One Bulb with 3 Switches
17. Find the minimum number of aircraft
18. Burning ropes to measure time
19. Connect 3 houses with 3 wells
20. Measure 9 minutes from 2 hourglasses puzzle
21. Ant and Triangle Problem
22. The Man in the Elevator
23. Find the survivor
24. Free the prisoners puzzle
25. GREAT STRATEGY CAN ONLY SAVE LIFE

Specially for Microsoft Interview Puzzles, you may refer,
Top 15 Microsoft Interview Puzzles
Microsoft Interview Puzzles

Other MOST COMMON Interview Puzzles-
Top 25 Tech Interview Logical Puzzles

Each of the puzzles got repeated a number of times in interviews even for top tech companies 

Address of the bookmark: https://github.com/mattharrison/Tiny-Python-3.6-Notebook/blob/master/python.rst

Why use AWK instead of Perl? Readability. AWK is easier to read than Perl. For simple text-processing scripts, particularly ones that read files line by line and split on delimiters, AWK is probably the right tool for the job.

#!/usr/bin/awk -f

# Comments are like this


# AWK programs consist of a collection of patterns and actions.
pattern1 { action; } # just like lex
pattern2 { action; }

# There is an implied loop and AWK automatically reads and parses each
# record of each file supplied. Each record is split by the FS delimiter,
# which defaults to white-space (multiple spaces,tabs count as one)
# You can assign FS either on the command line (-F C) or in your BEGIN
# pattern

# One of the special patterns is BEGIN. The BEGIN pattern is true
# BEFORE any of the files are read. The END pattern is true after
# an End-of-file from the last file (or standard-in if no files specified)
# There is also an output field separator (OFS) that you can assign, which
# defaults to a single space

BEGIN {

    # BEGIN will run at the beginning of the program. It's where you put all
    # the preliminary set-up code, before you process any text files. If you
    # have no text files, then think of BEGIN as the main entry point.

    # Variables are global. Just set them or use them, no need to declare..
    count = 0;

    # Operators just like in C and friends
    a = count + 1;
    b = count - 1;
    c = count * 1;
    d = count / 1; # integer division
    e = count % 1; # modulus
    f = count ^ 1; # exponentiation

    a += 1;
    b -= 1;
    c *= 1;
    d /= 1;
    e %= 1;
    f ^= 1;

    # Incrementing and decrementing by one
    a++;
    b--;

    # As a prefix operator, it returns the incremented value
    ++a;
    --b;

    # Notice, also, no punctuation such as semicolons to terminate statements

    # Control statements
    if (count == 0)
        print "Starting with count of 0";
    else
        print "Huh?";

    # Or you could use the ternary operator
    print (count == 0) ? "Starting with count of 0" : "Huh?";

    # Blocks consisting of multiple lines use braces
    while (a < 10) {
        print "String concatenation is done" " with a series" " of"
            " space-separated strings";
        print a;

        a++;
    }

    for (i = 0; i < 10; i++)
        print "Good ol' for loop";

    # As for comparisons, they're the standards:
    # a < b   # Less than
    # a <= b  # Less than or equal
    # a != b  # Not equal
    # a == b  # Equal
    # a > b   # Greater than
    # a >= b  # Greater than or equal

    # Logical operators as well
    # a && b  # AND
    # a || b  # OR

    # In addition, there's the super useful regular expression match
    if ("foo" ~ "^fo+$")
        print "Fooey!";
    if ("boo" !~ "^fo+$")
        print "Boo!";

    # Arrays
    arr[0] = "foo";
    arr[1] = "bar";

    # You can also initialize an array with the built-in function split()

    n = split("foo:bar:baz", arr, ":");

    # You also have associative arrays (actually, they're all associative arrays)
    assoc["foo"] = "bar";
    assoc["bar"] = "baz";

    # And multi-dimensional arrays, with some limitations I won't mention here
    multidim[0,0] = "foo";
    multidim[0,1] = "bar";
    multidim[1,0] = "baz";
    multidim[1,1] = "boo";

    # You can test for array membership
    if ("foo" in assoc)
        print "Fooey!";

    # You can also use the 'in' operator to traverse the keys of an array
    for (key in assoc)
        print assoc[key];

    # The command line is in a special array called ARGV
    for (argnum in ARGV)
        print ARGV[argnum];

    # You can remove elements of an array
    # This is particularly useful to prevent AWK from assuming the arguments
    # are files for it to process
    delete ARGV[1];

    # The number of command line arguments is in a variable called ARGC
    print ARGC;

    # AWK has several built-in functions. They fall into three categories. I'll
    # demonstrate each of them in their own functions, defined later.

    return_value = arithmetic_functions(a, b, c);
    string_functions();
    io_functions();
}

# Here's how you define a function
function arithmetic_functions(a, b, c,     d) {

    # Probably the most annoying part of AWK is that there are no local
    # variables. Everything is global. For short scripts, this is fine, even
    # useful, but for longer scripts, this can be a problem.

    # There is a work-around (ahem, hack). Function arguments are local to the
    # function, and AWK allows you to define more function arguments than it
    # needs. So just stick local variable in the function declaration, like I
    # did above. As a convention, stick in some extra whitespace to distinguish
    # between actual function parameters and local variables. In this example,
    # a, b, and c are actual parameters, while d is merely a local variable.

    # Now, to demonstrate the arithmetic functions

    # Most AWK implementations have some standard trig functions
    localvar = sin(a);
    localvar = cos(a);
    localvar = atan2(b, a); # arc tangent of b / a

    # And logarithmic stuff
    localvar = exp(a);
    localvar = log(a);

    # Square root
    localvar = sqrt(a);

    # Truncate floating point to integer
    localvar = int(5.34); # localvar => 5

    # Random numbers
    srand(); # Supply a seed as an argument. By default, it uses the time of day
    localvar = rand(); # Random number between 0 and 1.

    # Here's how to return a value
    return localvar;
}

function string_functions(    localvar, arr) {

    # AWK, being a string-processing language, has several string-related
    # functions, many of which rely heavily on regular expressions.

    # Search and replace, first instance (sub) or all instances (gsub)
    # Both return number of matches replaced
    localvar = "fooooobar";
    sub("fo+", "Meet me at the ", localvar); # localvar => "Meet me at the bar"
    gsub("e+", ".", localvar); # localvar => "m..t m. at th. bar"

    # Search for a string that matches a regular expression
    # index() does the same thing, but doesn't allow a regular expression
    match(localvar, "t"); # => 4, since the 't' is the fourth character

    # Split on a delimiter
    n = split("foo-bar-baz", arr, "-"); # a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3

    # Other useful stuff
    sprintf("%s %d %d %d", "Testing", 1, 2, 3); # => "Testing 1 2 3"
    substr("foobar", 2, 3); # => "oob"
    substr("foobar", 4); # => "bar"
    length("foo"); # => 3
    tolower("FOO"); # => "foo"
    toupper("foo"); # => "FOO"
}

function io_functions(    localvar) {

    # You've already seen print
    print "Hello world";

    # There's also printf
    printf("%s %d %d %d\n", "Testing", 1, 2, 3);

    # AWK doesn't have file handles, per se. It will automatically open a file
    # handle for you when you use something that needs one. The string you used
    # for this can be treated as a file handle, for purposes of I/O. This makes
    # it feel sort of like shell scripting, but to get the same output, the string
    # must match exactly, so use a variable:

    outfile = "/tmp/foobar.txt";

    print "foobar" > outfile;

    # Now the string outfile is a file handle. You can close it:
    close(outfile);

    # Here's how you run something in the shell
    system("echo foobar"); # => prints foobar

    # Reads a line from standard input and stores in localvar
    getline localvar;

    # Reads a line from a pipe (again, use a string so you close it properly)
    cmd = "echo foobar";
    cmd | getline localvar; # localvar => "foobar"
    close(cmd);

    # Reads a line from a file and stores in localvar
    infile = "/tmp/foobar.txt";
    getline localvar < infile; 
    close(infile);
}

# As I said at the beginning, AWK programs consist of a collection of patterns
# and actions. You've already seen the BEGIN pattern. Other
# patterns are used only if you're processing lines from files or standard
# input.
#
# When you pass arguments to AWK, they are treated as file names to process.
# It will process them all, in order. Think of it like an implicit for loop,
# iterating over the lines in these files. these patterns and actions are like
# switch statements inside the loop. 

/^fo+bar$/ {

    # This action will execute for every line that matches the regular
    # expression, /^fo+bar$/, and will be skipped for any line that fails to
    # match it. Let's just print the line:

    print;

    # Whoa, no argument! That's because print has a default argument: $0.
    # $0 is the name of the current line being processed. It is created
    # automatically for you.

    # You can probably guess there are other $ variables. Every line is
    # implicitly split before every action is called, much like the shell
    # does. And, like the shell, each field can be access with a dollar sign

    # This will print the second and fourth fields in the line
    print $2, $4;

    # AWK automatically defines many other variables to help you inspect and
    # process each line. The most important one is NF

    # Prints the number of fields on this line
    print NF;

    # Print the last field on this line
    print $NF;
}

# Every pattern is actually a true/false test. The regular expression in the
# last pattern is also a true/false test, but part of it was hidden. If you
# don't give it a string to test, it will assume $0, the line that it's
# currently processing. Thus, the complete version of it is this:

$0 ~ /^fo+bar$/ {
    print "Equivalent to the last pattern";
}

a > 0 {
    # This will execute once for each line, as long as a is positive
}

# You get the idea. Processing text files, reading in a line at a time, and
# doing something with it, particularly splitting on a delimiter, is so common
# in UNIX that AWK is a scripting language that does all of it for you, without
# you needing to ask. All you have to do is write the patterns and actions
# based on what you expect of the input, and what you want to do with it.

# Here's a quick example of a simple script, the sort of thing AWK is perfect
# for. It will read a name from standard input and then will print the average
# age of everyone with that first name. Let's say you supply as an argument the
# name of a this data file:
#
# Bob Jones 32
# Jane Doe 22
# Steve Stevens 83
# Bob Smith 29
# Bob Barker 72
#
# Here's the script:

BEGIN {

    # First, ask the user for the name
    print "What name would you like the average age for?";

    # Get a line from standard input, not from files on the command line
    getline name < "/dev/stdin";
}

# Now, match every line whose first field is the given name
$1 == name {

    # Inside here, we have access to a number of useful variables, already
    # pre-loaded for us:
    # $0 is the entire line
    # $3 is the third field, the age, which is what we're interested in here
    # NF is the number of fields, which should be 3
    # NR is the number of records (lines) seen so far
    # FILENAME is the name of the file being processed
    # FS is the field separator being used, which is " " here
    # ...etc. There are plenty more, documented in the man page.

    # Keep track of a running total and how many lines matched
    sum += $3;
    nlines++;
}

# Another special pattern is called END. It will run after processing all the
# text files. Unlike BEGIN, it will only run if you've given it input to
# process. It will run after all the files have been read and processed
# according to the rules and actions you've provided. The purpose of it is
# usually to output some kind of final report, or do something with the
# aggregate of the data you've accumulated over the course of the script.

END {
    if (nlines)
        print "The average age for " name " is " sum / nlines;
}