You can also add your favourite NGS educational material, or workshop tutorial by commenting on this bookmarks for user benefit. 

Understanding the basics of genome sequencing:

Tutorial by Luke Jostins.

http://www.genetic-inference.co.uk/blog/2009/04/basics-sequencing-dna-part-1/

http://www.genetic-inference.co.uk/blog/2009/08/basics-sequencing-dna-part-2/

A window into third-generation sequencing

http://hmg.oxfordjournals.org/content/19/R2/R227.full.pdf

==============================================

NGS data analysis pipelines

• Detecting and annotating genetic variations using the HugeSeq pipeline  DOI: 10.1038/nbt.2134
• NARWHAL, a primary analysis pipeline for NGS data http://bioinformatics.oxfordjournals.org/cgi/content/abstract/28/2/284?etoc
• RseqFlow: Workflows for RNA-Seq data analysis  DOI: 10.1093/bioinformatics/btr441
• ngs_backbone: a pipeline for read cleaning, mapping and SNP calling using Next Generation Sequence  10.1186/1471-2164-12-285
• A framework for variation discovery and genotyping using next-generation DNA sequencing data  PubMed: 21478889
• SNiPlay: a web-based tool for detection, management and analysis of SNPs. Application to grapevine diversity projects  DOI: 10.1186/1471-2105-12-134 Abstract: http://www.biomedcentral.com/1471-2105/12/134/abstract
• WEP: a high-performance analysis pipeline for whole-exome data http://www.biomedcentral.com/1471-2105/14/S7/S11
• DDBJ read annotation pipeline: a cloud computing-based pipeline for high-throughput analysis of next-generation sequencing data. http://www.ncbi.nlm.nih.gov/pubmed/23657089
• GATK: a Toolkit for Genome Analysis http://www.broadinstitute.org/gatk/
• Metagenomics:http://www.nbic.nl/education/nbic-phd-school/course-schedule/ngsmetagenomics/
• RNASeq:http://www.nbic.nl/education/nbic-phd-school/course-schedule/ngsrnaseq/
• Bioinformatics and Seq courses: http://www.isb-sib.ch/training/training-activities-schedule/archive-2013.html
• Variant Detection (Model organism) Advanced tutorial https://docs.google.com/document/pub?id=1CuKkKylVDb03tnN7RSWl5EUzleetn0ctjmvaidPKLxM
• Variant Detection Introductory tutorial https://docs.google.com/document/pub?id=1ZRzrjjOCvtAu3m-IKL-rbJ1f4On60dDL_IEwG7oejdI
• Microbial de novo Assembly for Illumina Data Introductory tutorial https://docs.google.com/document/pub?id=1N3AB9ptISUu4zULqe1kXpVF0BDyGb5f5yzxWSJd_WNM
• RNAseq Differential Gene Expression Introductory tutorial https://docs.google.com/document/pub?id=1KbTiBHtvHLfPRZ39AY3uriazrINA8TJzgjjwn1zPP7Y

" Please add your favourite NGS link below in comment section for the benefit of bioinformatics community ". 

Address of the bookmark: http://chagall.med.cornell.edu/NGScourse/

Reference@http://www.datasciencecentral.com/profiles/blogs/one-page-r-a-survival-guide-to-data-science-with-r

• Templates for the Data Scientist
  1. A Template for Preparing Data: *OnePageR - *R
  2. A Template for Building Models: *OnePageR - *R
• Getting Started as a Data Scientist
  1. Getting Started with R and Rattle: *Lecture - *Laboratory
  2. Introducing and Interacting with R: *Lecture - *Laboratory
  3. BasicR - OnePage(R) - Writing R scripts
• Dealing With Data
  1. Read Data into R: *OnePageR - *R
  2. Explore and Summarise Data: *OnePageR - *R
  3. Transform Data: *OnePageR - *R
  4. Dealing with Dates and Time: (PDF, R) Dates and Time
  5. Visualising Data with GGPlot2: *OnePageR - *R
  6. Visualising Data with Maps *OnePageR - *R
  7. Spatial (R) Spatial Analysis
  8. Handling Big Data *OnePageR - *R
• Descriptive Analytics
  1. Cluster Analysis: *Lecture - *OnePageR - *R
  2. Association Analysis: *Lecture
• Predictive Analytics
  1. Decision Trees: *Lecture - *OnePageR - *R - *Rattle
  2. Ensembles of Decision Trees: *Lecture - *OnePageR - *R
  3. SVM (R)
  4. KernLab (R)
  5. NeuralNetworks (R)
  6. NNet (R)
• Model Delivery
  1. Evaluating Models: *OnePageR - *R
  2. Evaluation (R)
  3. Scoring (R)
  4. PMML (R) Exporting Models for Deployment
• Advanced Topics
  1. Text Mining: *OnePageR - *R
• Advanced R Topics
  1. Plots (PDF, R) Miscellaneous Plots
  2. Functions (PDF, R) Writing Functions in R
  3. Parallel (PDF, R) Parallel Execution
  4. Packaging (R) Pulling it Together into a Package
  5. Doing R with Style: *OnePageR - *R
  6. Literate Data Mining with KnitR: *Lecture - *OnePageR - *

What are SNPs?
SNPs (pronounced "snips") are positions in the genome where individuals differ by a single nucleotide. For example:

Reference: ...A T G C A T G A...
Variant:     ...A T G T A T G A...

Here, the C in the reference genome has been replaced by a T in the variant.

SNPs occur roughly every 300–1,000 bases in the human genome, meaning there are millions of them scattered throughout our DNA. Most SNPs have no effect on health, but some are linked to disease susceptibility, drug response, and other traits.

Why Do We Analyze SNPs?
1. Medical Genetics

Identify disease-associated variants (e.g., BRCA1/2 in breast cancer).

Predict drug response (pharmacogenomics).

Enable precision medicine by tailoring treatments.

2. Population Genetics & Ancestry

Trace human migration and ancestry.

Study genetic diversity within and between populations.

3. Agriculture & Animal Breeding

Select for desirable traits (drought resistance, yield, disease resistance).

Improve breeding efficiency in livestock.

4. Evolutionary Biology

Track natural selection.

Study adaptation in wild populations.

How is SNP Analysis Performed?
SNP analysis can be broadly divided into three steps:

SNP Detection
Genotyping arrays: Chips that test hundreds of thousands of known SNP positions simultaneously. Fast and affordable, widely used in consumer ancestry testing.

Whole-genome or whole-exome sequencing: Can detect known and novel SNPs across the genome.

Targeted sequencing or PCR: For focused analysis of specific regions.

Variant Calling
Sequencing data is aligned to a reference genome. Bioinformatics tools (e.g., GATK, bcftools) identify positions where the sequenced sample differs from the reference.

Annotation and Interpretation
Tools (e.g., SnpEff, VEP) predict the functional impact of SNPs.

Are the SNPs in coding regions? Do they cause amino acid changes? Are they known to be pathogenic?

Databases like dbSNP, ClinVar, and GWAS Catalog provide information on known associations.

Common Tools for SNP Analysis
Alignment: BWA, Bowtie2

Variant Calling: GATK, FreeBayes

Visualization: IGV, UCSC Genome Browser

Annotation: SnpEff, VEP

Statistical Analysis: PLINK, SNPTEST

Challenges in SNP Analysis
False positives/negatives: Sequencing errors, alignment issues.

Population stratification: Confounding in association studies.

Interpretation: Many SNPs have unknown or complex effects.

Researchers address these with rigorous quality control, large datasets, and increasingly sophisticated statistical models.

The Future of SNP Analysis
With advances in sequencing technology and AI-driven analysis, SNP studies are expanding:

Polygenic risk scores predict disease risk based on thousands of SNPs.

Large-scale biobanks (e.g., UK Biobank, All of Us) enable powerful genome-wide association studies (GWAS).

CRISPR and functional assays help validate SNP effects in the lab.

SNP analysis is at the heart of the genomic revolution, promising insights into biology, health, and evolution at unprecedented scale.

Conclusion
From diagnosing rare diseases to designing better crops, SNP analysis is a foundational tool in modern science. As our ability to sequence and interpret genomes improves, so will our understanding of these tiny—but mighty—variations in DNA.

Following are the useful links:

Single Cell RNAseq data analysis Tutorial

A step-by-step workflow for low-level analysis of single-cell RNA-seq data

A step-by-step workflow for low-level analysis of single-cell RNA-seq data with Bioconductor

SCell: single-cell RNA-seq analysis software

https://github.com/diazlab/SCell

Beta-Poisson model for single-cell RNA-seq data analyses

https://github.com/nghiavtr/BPSC

Sincera: A Computational Pipeline for Single Cell RNA-Seq Profiling Analysis

https://research.cchmc.org/pbge/sincera.html

SC3 – consensus clustering of single-cell RNA-Seq data

http://biorxiv.org/content/early/2016/09/02/036558

Citrus: A toolkit for single cell sequencing analysis

http://biorxiv.org/content/early/2016/09/14/045070

Single-Cell Resolution of Temporal Gene Expression during Heart Development

http://www.cell.com/developmental-cell/fulltext/S1534-5807(16)30682-7

Scalable latent-factor models applied to single-cell RNA-seq data separate biological drivers from confounding effects

http://biorxiv.org/content/early/2016/11/15/087775

Single cell transcriptomes identify human islet cell signatures and reveal cell-type-specific expression changes in type 2 diabetes

http://genome.cshlp.org/content/early/2016/11/18/gr.212720.116.abstract

SCODE: An efficient regulatory network inference algorithm from single-cell RNA-Seq during differentiation

http://biorxiv.org/content/early/2016/11/21/088856

SCOUP is a probabilistic model to analyze single-cell expression data during differentiation

https://github.com/hmatsu1226/SCOUP

scLVM is a modelling framework for single-cell RNA-seq data

https://github.com/PMBio/scLVM

Selective Locally linear Inference of Cellular Expression Relationships (SLICER) algorithm for inferring cell trajectories

https://github.com/jw156605/SLICER

SinQC: A Method and Tool to Control Single-cell RNA-seq Data Quality

http://www.morgridge.net/SinQC.html

TSCAN: Pseudo-time reconstruction and evaluation in single-cell RNA-seq analysis

https://github.com/zji90/TSCAN

Visualization and cellular hierarchy inference of single-cell data using SPADE

http://www.nature.com/nprot/journal/v11/n7/full/nprot.2016.066.html

OEFinder: Identify ordering effect genes in single cell RNA-seq data

https://github.com/lengning/OEFinder

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;
}

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

PRINCIPAL SCIENTIST Pay Band: Minimum pay of `43,000 in the PB-4 of `37400-67000/- + RGP of `10,000/-.

Age: The candidates must not have attained the age of 52 years as on 24.03.2015. There shall be no age limit for the Council’s employees.

ICAR-NATIONAL INSTITUTE OF BIOTIC STRESS MANAGEMENT, RAIPUR (CHHATTISGARH)

57. Principal Scientist (Agricultural Entomology) (Two post)

Qualifications Essential:

(i) Doctoral degree in Agricultural Entomology including relevant basic sciences.

(ii) 10 years experience in the relevant subject out of which at least 8 years should be as Scientist/ Lecturer/Extension Specialist or in an equivalent position in the Pay Band- 3 of `15600-39100 with Grade Pay of `5400/`6000/`7000/`8000 and 2 years as a Senior Scientist or in an equivalent position in the Pay Band- 4 of ` 37400-67000 with Grade Pay of ` 8700/ ` 9000.

(iii) The candidate should have made contribution to research/teaching/extension education as evidenced by published work/innovations and impact.

Desirable:

(i) Experience of using frontiers research tools in management of insect pests of crop plants.

(ii) Evidence of contributions to relevant field through publications/ patents/citation index to suggest a vision/perspective in biotic stress research.

61. Principal Scientist (Bioinformatics) (One post)

Qualifications Essential:

(i) Doctoral degree in Bioinformatics including relevant basic sciences. (ii) & (iii) As in item no. 57 above.

Desirable:

(i) Experience of using bioinformatics for advancement of knowledge and for research on biotic stress management.

(ii) Evidence of contributions to relevant field through publications/patents/citation index to suggest a vision/perspective in biotic stress research.

http://asrb.org.in/administrator/uploads_dir/1424859407english.pdf

ICAR-NPTC: Fibre development in flax/linseed.

(Job # 1) Research Associate (one) (Bioinformatics)

Rs.24000+ 30% HRA) for Ph.D. and for M. Sc Rs.23000/‐ (+ 30% HRA)

Ph.D. Degree in Bioinformatics/Molecular Biology/Biotechnology/ Genetics/allied sciences; or M. Sc in Bioinformatics/ Biotechnology/Life Sciences/ allied sciences with 1st division or 60% marks or equivalent overall grade point average with at least two years of research experience as evidenced from Fellowship/ Associate ship. 2 years research experience in bioinformatic data analysis/molecular biology techniques, and high throughput DNA/RNA sequencing, and transcriptome data analysis. Research paper with IF>1 will be desirable

ICAR-NPTC: Shade avoidance/low-light tolerance in rice.

General Terms & Conditions applicable to all the positions:
Age Limit: 35 years max. (5 years relaxation for SC/ST/OBC and woman candidates as per ICAR rules).
The positions are purely temporary, on a contractual basis and are initially offered for one year.
Originals must be shown for verification. 7. Research experience (Experience certificate from previous employer to be attached): I hereby declare that the information provided above is true to the best of my knowledge. Date: Signature

Advertisement:

www.nrcpb.org/sites/default/files/ICAR-NPTC%20DBT%20RA%20SRF%20interview%2024th%20March.pdf

More at http://www.bx.psu.edu/~rsharris/lastz/

Thesis: http://www.bx.psu.edu/~rsharris/rsharris_phd_thesis_2007.pdf

Address of the bookmark: http://www.bx.psu.edu/~rsharris/lastz/