Question: Both $\ce{SF6}$ and $\ce{SH6}$ and $\ce{SF4}$ and $\ce{SH4}$ have the same central atom and the same hybridization, but my teacher specifically mentioned that $\ce{SH6}$ and $\ce{SH4}$ don't exist. I've looked everywhere but I can't figure out why? I'd appreciate some insight into the problem.

TL;DR Fluorine is electronegative and can support the extra negative charge that is dispersed on the six X atoms in $\ce{SX6}$, whereas hydrogen cannot.

First, let's debunk a commonly taught myth, which is that the bonding in $\ce{SF6}$ involves promotion of electrons to the 3d orbitals with a resulting $\mathrm{sp^3d^2}$ hybridisation. This is not true. Here's a recent and arguably more understandable reference: J. Chem. Educ. 2020, 97 (10), 3638–3646 which explains this. Quoting:

The natural ionicity, $i_\ce{SF}$, of each $\ce{S-F}$ bond [in $\ce{SF6}$] is 0.86, indicating a rather ionic σ bond. Each fluorine has an average charge of $−0.45$, resulting in a sulfur center of charge $+2.69$. [...] In summary, the electronic structure of this system is best described as a sulfur center with a charge somewhere between $2+$ and $3+$; the corresponding negative charge is distributed among the equivalent fluorine atoms. Shown in Figure 12 is the orbital occupation of the sulfur center, $\ce{3s^1 3p^{2.1} 3d^{0.19} 5p^{0.03} 4f^{0.01}}$. The minimal occupation of d-type orbitals eliminates the possibility of $\mathrm{sp^3d^2}$ hybridization.

If not via d-orbital bonding, how does one then describe the structure of $\ce{SF6}$? I'll present an LCAO-MO answer. Here's a "simple" MO diagram (I won't go through the details of how to construct it). It's actually fairly similar to that of an octahedral transition metal complex, except that here the 3s and 3p orbitals on sulfur are below the 3d orbitals.

Just for the sake of counting electrons, I treated the compound as being "fully ionic", i.e. $\ce{S^6+} + 6\ce{F-}$. So sulfur started off with 0 valence electrons, and each fluorine started off with 2 electrons in its σ orbitals. I've also neglected the π contribution to bonding, so the fluorine lone pairs don't appear in the diagram.
You'll see that, for a total of six $\ce{S-F}$ bonds, we only have four pairs of electrons in bonding MOs. The other two pairs of electrons reside in the $\mathrm{e_g}$ MOs, which are nonbonding and localised on fluorine. If we want to assign a formal charge to sulfur based on this diagram, it would be +2, because there are only actually four bonds. We could perhaps use Lewis diagrams to represent it this way:

The "hypervalent" resonance form contributes rather little and does not rely on invoking d-orbital participation; see Martin's comment on my answer below for greater detail about the resonance contributions. I am guessing that its existence can be mostly attributed to negative hyperconjugation, although I'm not 100% sure on this. The trans and cis resonance forms are not equal, so their contribution is not the same, but the contribution from each individual trans resonance form has to be the same by symmetry. Overall, the six fluorines in $\ce{SF6}$ have to be equivalent by the octahedral symmetry of the molecule. You could run a $\ce{^19F}$ NMR of the compound and it should only give you one peak.
(An alternative way of looking at it is that two of the $\ce{S-F}$ bonds are "true" 2c2e bonds, and that the other four $\ce{S-F}$ "bonds" are in fact just a couple of 3c4e bonds, but I won't go into that. For more information on multi-centre bonds, this article is a nice introduction: J. Chem. Educ. 1998, 75, 910; see also refs. 12 and 13 in that article.)
Right from the outset, we can see why $\ce{SH6}$ is not favoured as much. If we use the same framework to describe the bonding in $\ce{SH6}$, then those "correct" resonance forms that we drew would involve $\ce{H-}$. I'll leave it to the reader to figure out whether $\ce{F-}$ or $\ce{H-}$ is more stable.
Alternatively, if you want to stick to the MO description, the idea is that in $\ce{SH6}$, the relatively high energy of H1s compared to F2p will lead to the nonbonding $\mathrm{e_g}$ orbitals being relatively higher in energy. All things being equal, it's less favourable for a higher-energy orbital to be occupied, and $\ce{SH6}$ would therefore be very prone to losing these electrons, i.e. being oxidised.
In fact, if we do remove those four electrons from the $\mathrm{e_g}$ orbitals, then it's possible that these six-coordinate hydrides could form. But obviously we might not want to have a $\ce{SH6^4+}$ molecule on the loose. It'll probably lose all of its protons in a hurry to get back to being $\ce{H2S + 4H+}$. Is there anything better? Well, there's the species $\ce{CH6^2+}$, which is methane protonated twice. It's valence isoelectronic with $\ce{SH6^4+}$, and if you want to read about it, here's an article: J. Am. Chem. Soc. 1983, 105, 5258. While it's hardly the most stable molecule on the planet, it's certainly more plausible than $\ce{SH6}$.
Now, just to come back to where we started from: d-orbital participation. Yes, there is an $\mathrm{e_g}$ set of d orbitals that can overlap with the apparently "nonbonding" $\mathrm{e_g}$ linear combination of F2p orbitals, thereby stabilising it. It is true that some degree of this does happen. The issue is how much. Considering the fairly large energy gap between the $\mathrm{e_g}$ orbitals, this interaction is bound to be fairly small, and is nowhere near enough to justify a $\mathrm{sp^3d^2}$ description of it; Martin's comments contain more details.


Question:
Please be kind, I am an electronics nub.  This is in reference to getting an LED to emit photons.
From what I read (Getting Started in Electronics - Forrest Mims III and Make: Electronics) electrons flow from the more negative side to the more positive side.
In an example experiment (involving a primary dry cell, a SPDT switch, a resistor and an LED) it states that the resistor MUST be connected to the anode of the LED.  In my mind, if the electrons flow from negative to positive, wouldn't the electron flow run through the LED before the resistor; thereby making the resistor pointless?

The resistor can be on either side of the LED, but it must be present.  When two or more components are in series, the current will be the same through all of them, and so it doesn't matter which order they are in.  I think the way to read "the resistor must be connected to the anode" as "the resistor cannot be omitted from the circuit."


Question:
I've thoroughly read the Wikipedia article on DNA sequencing and can't get one thing.
There's some hardcore chemistry involved in the process that somehow splits the DNA and then isolates its parts.
Yet DNA sequencing is considered to be a very computationally-intensive process. I don't get what exactly is being computed there - what data comes into computers and what computers compute specifically.
What exactly is being computed there? Where do I get more information on this?

Computers are used in several steps of sequencing, from the raw data to finished sequence:
Image processing
Modern sequencers usually use fluorescent labelling of DNA fragments in solution. The fluorescence encodes the different nucleobase (= “base”) types (generally called A, C, G and T). To achieve high throughput, millions of sequencing reactions are performed in parallel in microscopic quantities on a glass chip, and for each micro-reaction, the label needs to be recorded at each step in the reaction.
This means: the sequencer takes progressive digital photographs of the chip containing the sequencing reagent. These photos have differently coloured pixels which need to be told apart and assigned a specific colour value.

As can be seen, this (strongly magnified; the image is < 100 µm across!) image fragment is fuzzy and many of the dots overlap. This makes it hard to determine which colour to assign to which pixel (though more recent versions of the sequencing machine have improved focussing systems, and the image is consequently crisper).
Base calling
One such image is registered for each step of the sequencing process, yielding one image for each base of the fragments. For a fragment of length 75, that’d be 75 images.
Once you have analysed the images, you get colour spectra for each pixel across the images. The spectra for each pixel correspond to one sequence fragment (often called a “read”) and are considered separately. So for each fragment you get such a spectrum:

(This image is generated by an alternative sequencing process called Sanger sequencing but the principle is the same.)
Now you need to decide which base to assign for each position based on the signal (“base calling”). For most positions this is fairly easy but sometimes the signal overlaps or decays significantly. This has to be considered when deciding the base calling quality (i.e. which confidence you assign to your decision for a given base).
Doing this for each read yields up to billions of reads, each representing a short fragment of the original DNA that you sequenced.
Most bioinformatics analysis starts here; that is, the machines emit files containing the short sequence fragments. Now we need to make a sequence from them.
Read mapping and assembly
The key point that allows retrieving the original sequence from these small fragments is the fact that these fragments are (non-uniformly) randomly distributed over the genome, and they are overlapping.
The next step depends on whether you have a similar, already sequenced genome at hand. Often, this is the case. For instance, there is a high-quality “reference sequence” of the human genome and since all the genomic sequences of all humans are ~99.9% identical (depending on how you count), you can simply look where your reads align to the reference.
Read mapping
This is done to search for single changes between the reference and your currently studied genome, for example to detect mutations that lead to diseases.
So all you have to do is to map the reads back to their original location in the reference genome (in blue) and look for differences (such as base pair differences, insertions, deletions, inversions …).

Two points make this hard:

You have got billions (!) of reads, and the reference genome is often several gigabytes large. Even with the fastest thinkable implementation of string search, this would take prohibitively long.

The strings don’t match precisely. First of all, there are of course differences between the genomes – otherwise, you wouldn’t sequence the data at all, you’d already have it! Most of these differences are single base pair differences – SNPs (= single nucleotide polymorphisms) – but there are also larger variations that are much harder to deal with (and they are often ignored in this step).
Furthermore, the sequencing machines aren’t perfect. A lot of things influence the quality, first and foremost the quality of the sample preparation, and minute differences in the chemistry. All this leads to errors in the reads.

In summary, you need to find the position of billions of small strings in a larger string which is several gigabytes in size. All this data doesn’t even fit into a normal computer’s memory. And you need to account for mismatches between the reads and the genome.
Unfortunately, this still doesn’t yield the complete genome. The main reason is that some regions of the genome are highly repetitive and badly conserved, so that it’s impossible to map reads uniquely to such regions.
As a consequence, you instead end up with distinct, contiguous blocks (“contigs”) of mapped reads. Each contig is a sequence fragment, like reads, but much larger (and hopefully with less errors).
Assembly
Sometimes you want to sequence a new organism so you don’t have a reference sequence to map to. Instead, you need to do a de novo assembly. An assembly can also be used to piece contigs from a mapped reads together (but different algorithms are used).
Again we use the property of the reads that they overlap. If you find two fragments which look like this:
ACGTCGATCGCTAGCCGCATCAGCAAACAACACGCTACAGCCT
ATCCCCAAACAACACGCTACAGCCTGGCGGGGCATAGCACTGG

You can be quite certain that they overlap like this in the genome:
ACGTCGATCGCTAGCCGCATCAGCAAACAACACGCTACAGCCT
                  ATCCCCATTCAACACGCTA-AGCTTGGCGGGGCATACGCACTG

(Notice again that this isn’t a perfect match.)
So now, instead of searching for all the reads in a reference sequencing, you search for head-to-tail correspondences between reads in your collection of billions of reads.
If you compare the mapping of a read to searching a needle in a haystack (an often used analogy), then assembling reads is akin to comparing all the straws in the haystack to each other straw, and putting them in order of similarity.


Question:
In physics, "almost everything is already discovered, and all that remains is to fill a few unimportant holes." (See Jolly.) Therefore, on Physics SE, people are veering off into different directions: biology, for example.
Thus, it happens that a question about bicycles generates some discussion about evolution in biology and animals with wheels.
Three explanations are offered for the apparent lack of wheely animals (also on Wikipedia, where, by the way, most Physics SE questions are answered perfectly).

Evolutionary constraints: "[A] complex structure or system will not evolve if its incomplete form provides no benefit to an organism."
Developmental and anatomical constraints.
Wheels have significant disadvantages (e.g., when not on roads).

Now, I suggest that all three can be "solved".

With time.
With a symbiotic relationship between a wheel-like animal and a "driver"-like animal, although this gets awfully close to a "driver"-animal to jump onto an actual (man-made) wheel. (So, perhaps, you can suggest a better loophole around this constraint.)
Roads are presumably not the only ecological niche where animals with wheels could thrive. I'm thinking of frozen lakes, although there skates would be better than wheels.

What, therefore, is the explanation for there not being any wheeled animals?
Please consider, in your answer, the counterfactual: What assumption of yours would be falsified once a wheely animal is discovered?

Wheels are possible on the molecular level — bacterial flagella are rotating cores inside a molecular motor, but wheels larger than the flagellum have not really been found.

Defining a wheel as a freely rotating joint that can rotate indefinitely in one direction, a single animal with a wheel is an improbable* development that would require a single animal have two separate parts (axle/wheel and body).
[*read as: pretty much impossible]
It's hard to imagine how such a thing could evolve.  A wheel and axle would need to be made of living tissue, otherwise it would be vulnerable to wear and tear.  Wheels also have problems going over uneven terrain, which is really all terrain animals live in.  It's difficult to imagine what sort of selection conditions would be strong enough to push animals away from legs.
If you include driver-vehicle symbionts where the 'car' and 'wheel' are actually two animals, then they have evolved. Parasites can have all sorts of symbiotic control over their victims including as means of transport. The Jewel Wasp is one which is the most suggestive of what you may be thinking. The wasp stings its victim (a cockroach) in the thorax to immobilize the animal and then again just behind its head.  After this, the wasp can ride the beetle, steering it by holding its antennae back to its nest where the roach is immobilized to feed the wasp larvae there.
(see section "Pet cockaroaches" in this reference.)
As to the three schools of thought you added to the question, I would probably rather say there were two strong arguments against.  The first is whether there is an evolutionary path to wheels (argument 1 in your question), which I doubt.  Given even a large amount of evolutionary time you will not see a naked human being able to fly on their own power.  Too many structural characteristics of the body plan have been made to all be reversed so that wings or other means of aerial conveyance will show up. The same can be said for wheels when the body plans have fins/legs/and wings already.
Argument 3, which I also tend to agree with, is perhaps more convincing.  By the time a pair of animals makes a symbiotic relationship to make an axel, or a single macroscopic animal evolves wheels, they will literally develop legs and walk away. When life came onto the land this happened, and since then it's happened several times.  It's sort of like saying that the random movement of water molecules might line up to run a stream uphill. Its possible, but there's just such a strong path downwards, that the statistical chances of you seeing it happen are nil.
This is a hypothetical case, but arguing this in a convincing way I think you would need to describe:  a) an environment with a selective advantage for wheels to evolve over legs or other similar adaptations,  perhaps based on the energy efficiency of wheels;   b) a physiological model for the wheels that convey a reasonable lifestyle for the wheel.
There are lots of questions that would need to be satisfied in our thought experiment.  Here are some: "the symbiotic wheel would be spinning constantly; if it died the driver creature would be completely defenseless"; "if the ground were bumpy, all these wheeled animals would get eaten"; "How would the wheel symbiont eat while its spinning all the time? Only fed by the driver? Even symbionts such as barnacles or lampreys on the flanks of sharks still have their own ability to feed."
Many similar questions of this sort ensue where there are many disadvantages which outweigh advantages for animals. e.g. "why are all the flying animals and fish and plants even more similar to airplanes than helicopters?"
Sorry if I seem negative, but way back in grad school I actually did go over some of these angles.

UPDATE: First Gear found in a Living Creature.
A European plant-hopper insect with one of the largest accelerations known in biology has been found to have gears!  (There's a movie on the article page.
)
The little bug has gears in its exoskeleton that synchronize its two jumping legs.  Once again selection surprises.

The gears themselves are an oddity. With gear teeth shaped like cresting waves, they look nothing like what you'd find in your car or in a fancy watch.  There could be two reasons for this. Through a mathematical oddity, there is a limitless number of ways to design intermeshing gears. So, either nature evolved one solution at random, or, as Gregory Sutton, coauthor of the paper and insect researcher at the University of Bristol, suspects, the shape of the issus's gear is particularly apt for the job it does. It's built for "high precision and speed in one direction," he says.

The gears do not rotate 360 degrees, but appear on the surface of two joints to synchronize them as they wind up like a circular spring.  The gear itself is not living tissue, so the bug solves the problem of regenerating the gear by growing a new set when it molts (i.e. gears that continually regenerate and heal are still unknown).  It also does not keep its gears throughout its lifecycle.  So the arguments here still stand; the exception still supports the rule.
Additional Note: In his book "the God Delusion" (Chapter 4 somewhere) Richard Dawkins muses that the flagellar motor is the only example of a freely rotating axle that he knows of, and that a wheeled animal might be a true example of 'irreducibly complexity' in biology... but the fact that there is no such example is probably to the point.


Question:
In a recent article of Amstat News, the authors (Mark van der Laan and Sherri Rose) stated that "We know that for large enough sample sizes, every study—including ones in which the null hypothesis of no effect is true — will declare a statistically significant effect.".
Well, I for one didn't know that. Is this true? Does it mean that hypothesis testing is worthless for large data sets?

It is not true.  If the null hypothesis is true then it will not be rejected more frequently at large sample sizes than small. There is an erroneous rejection rate that's usually set to 0.05 (alpha) but it is independent of sample size. Therefore, taken literally the statement is false. Nevertheless, it's possible that in some situations (even whole fields) all nulls are false and therefore all will be rejected if N is high enough. But is this a bad thing?
What is true is that trivially small effects can be found to be "significant" with very large sample sizes.  That does not suggest that you shouldn't have such large samples sizes.  What it means is that the way you interpret your finding is dependent upon the effect size and sensitivity of the test.  If you have a very small effect size and highly sensitive test you have to recognize that the statistically significant finding may not be meaningful or useful.
Given some people don't believe that a test of the null hypothesis, when the null is true, always has an error rate equal to the cutoff point selected for any sample size, here's a simple simulation in R proving the point. Make N as large as you like and the rate of Type I errors will remain constant.
# number of subjects in each condition
n <- 100
# number of replications of the study in order to check the Type I error rate
nsamp <- 10000

ps <- replicate(nsamp, {
    # population mean = 0, sd = 1 for both samples, therefore, no real effect
    y1 <- rnorm(n, 0, 1)
    y2 <- rnorm(n, 0, 1)
    tt <- t.test(y1, y2, var.equal = TRUE)
    tt$p.value
})
sum(ps < .05) / nsamp

# ~ .05 no matter how big n is. Note particularly that it is
# not an increasing value always finding effects when n is very large.


Question:
It is known that HIV is usually transmitted by direct blood or body fluid contact between an infected individual and a healthy person (like blood transfusion or needle sharing):
Suppose a mosquito bites an individual suffering from AIDS and in the process sucks up some T cells infected with HIV along with RBCs. Then it bites another person not suffering from the disease, and transfers these infected T cells. Isn't there a high probability of the second individual contracting HIV?

No, this is not possible. There are a few reasons for that, but most important are that the only thing a mosquito injects is its own saliva, while the blood is sucked into the stomach where it is digested.
To be able to infect other people HIV would need to be able to leave the gut intact and then also be able to replicate in the mosquitos which it cannot do, due to the missing of the CD4 antigen on the surface of the insect cells. These are needed as a surface receptor for the virus to bind and enter the cells. This is also true for other blood sucking insects like bed bugs or fleas.
Other pathogens can do this, examples would be Yellow fever or Malaria. In Yellow fever the virus first infects epithelial cells of the gut, then enters the blood system of the insect to finally end up in the salivary glands, where the virus is injected together with the saliva into the biten person. In Malaria the pathogen is also able to leave the gut region and mature in the salivary glands.
HIV can only be transmitted through blood (either through direct transmission, operations etc.), through semen (cum), pre-seminal fluid (pre-cum), rectal fluids, vaginal fluids, and breast milk. See reference 3.
References:

Why Mosquitoes cannot transmit AIDS
Can we get AIDS from mosquito bites?
HIV Transmission Risk:  A Summary of Evidence


Question:
I am working with a set of (bulk) RNA-Seq data collected across multiple runs, run at different times of the year. I have normalized my data using library size / quantile / RUV normalization, and would like to check (quantitatively and/or qualitatively) whether or not normalization has succeeded in removing the batch effects.
It is important to note that by "normalization has succeeded", I simply mean that unwanted variation has been removed - further analysis is required to ensure that biological variation has not been removed. What are some plots / statistical tests / software packages which provide a first-step QC for normalization?

You should use box plots and PCA plot. Let's take a look at the RUV paper:

Before normalization and after UQ normalization:

Libraries do not cluster as expected according to treatment. ... for UQ-normalized counts. UQ normalization does not lead to better clustering of the samples...

Before normalization, the medians in the box-plot obviously look very different among replicates.
After UQ normalization, the medians look closer but Trt.11 look like an outlier. Furthermore, the treatments aren't clustered on the PCA plot. Since they are replicates, you'd like them be close on the plot.
After RUV normalization

... RUVg shrinks the expression measures for Library 11 towards the median across libraries, suggesting robustness against outliers. ... Libraries cluster as expected by treatment. ...

The RUV has made the distribution more robust and the samples closer on the PCA plot. However, it's still not perfect as one of the treatments is not close to the other two on the first PC.
The vignettes for Bioconductor RUVSeq describes the two functions: plotRLE and plotPCA.


Question:
I have finished developing an app for Android and intend to publish it with GPL -- I want it to be open source.
However, the nature of the application (a game) is that it asks riddles and has the answers coded into the string resource. I can't publish the answers!
I was told to look into storing passwords securely -- but I haven't found anything appropriate.
Is it possible to publish my source code with a string array hidden, encrypted, or otherwise obscured? Maybe by reading the answers from an online database?
Update
Yuval Filmus's solution below worked. When I first read it I was still not sure how to do it. I found some solutions, for the second option: storing the hashed solution in the source and calculating the hash everytime the user guesses. To do this in javascript there is the crypto-js library at
For Android, use the MessageDigest function. There is an application (on fdroid/github) called HashPass which does this.

You have at least two options, depending on what problem you want to solve.
If you want innocent readers of your code to not get the answers inadvertently, or you at least want to make it a bit difficult so that users are not tempted, you can encrypt the solutions and store the key as part of your code, perhaps a result of some computation (to make it even more difficult).
If you want to prevent users from retrieving the answer, you can use a one-way function, or in computer jargon, a hash function. Store a hash of the answer, and they you can test whether the answer is correct without it being possible to deduce the answer at all without finding it first. This has the disadvantage that it is harder to check for an answer that is close to the correct answer, though there are some solutions even to this problem.


Question:
I'll be generous and say it might be reasonable to assume that nature would tend to minimize, or maybe even maximize, the integral over time of $T-V$.  Okay, fine.  You write down the action functional, require that it be a minimum (or maximum), and arrive at the Euler-Lagrange equations.  Great.  But now you want these Euler-Lagrange equations to not just be derivable from the Principle of Least Action, but you want it to be equivalent to the Principle of Least Action.  After thinking about it for awhile, you realize that this implies that the Principle of Least Action isn't really the Principle of Least Action at all:  it's the "Principle of Stationary Action".  Maybe this is just me, but as generous as I may be, I will not grant you that it is "natural" to assume that nature tends to choose the path that is stationary point of the action functional.  Not to mention, it isn't even obvious that there is such a path, or if there is one, that it is unique.
But the problems don't stop there.  Even if you grant the "Principle of Stationary Action" as fundamentally and universally true, you realize that not all the equations of motions that you would like to have are derivable from this if you restrict yourself to a Lagrangian of the form $T-V$.  As far as I can tell, from here it's a matter of playing around until you get a Lagrangian that produces the equations of motion you want.
From my (perhaps naive point of view), there is nothing at all particularly natural (although I will admit, it is quite useful) about the formulation of classical mechanics this way.  Of course, this wouldn't be such a big deal if these classical ideas stayed with the classical physics, but these ideas are absolutely fundamental to how we think about things as modern as quantum field theory.
Could someone please convince me that there is something natural about the choice of the Lagrangian formulation of classical mechanics (I don't mean in comparison with the Hamiltonian formulation; I mean period), and in fact, that it is so natural that we would not even dare abandon these ideas?

Could someone please convince me that there is something natural about
  the choice of the Lagrangian formulation...

If I ask a high school physics student, "I am swinging a ball on a string around my head in a circle.  The string is cut.  Which way does the ball go?", they will probably tell me that the ball goes straight out - along the direction the string was pointing when it was cut.  This is not right; the ball actually goes along a tangent to the circle, not a radius.  But the beginning student will probably think this is not natural.  How do they lose this instinct?  Probably not by one super-awesome explanation.  Instead, it's by analyzing more problems, seeing the principles applied in new situations, learning to apply those principles themselves, and gradually, over the course of months or years, building what an undergraduate student considers to be common intuition.
So my guess is no, no one can convince you that the Lagrangian formulation is natural.  You will be convinced of that as you continue to study more physics, and if you expect to be convinced of it all at once, you are going to be disappointed.  It is enough for now that you understand what you've been taught, and it's good that you're thinking about it.  But I doubt anyone can quickly change your mind.  You'll have to change it for yourself over time.
That being said, I think the most intuitive way to approach action principles is through the principle of least (i.e. stationary) time in optics.  Try Feynman's QED, which gives a good reason to believe that the principle of stationary time is quite natural.
You can go further mathematically by learning the path integral formulation of nonrelativistic quantum mechanics and seeing how it leads to high probability for paths of stationary action.
More importantly, just use Lagrangian mechanics as much as possible, and not just finding equations of motion for twenty different systems. Use it to do interesting things.  Learn how to see the relationship between symmetries and conservation laws in the Lagrangian approach.  Learn about relativity.  Learn how to derive electromagnetism from an action principle - first by studying the Lagrangian for a particle in an electromagnetic field, then by studying the electromagnetic field itself as described by a Lagrange density.  Try to explain it to someone - their questions will sharpen your understanding.  Check out Leonard Susskind's lectures on YouTube (series 1 and 3 especially).  They are the most intuitive source I know for this material.
Read some of the many questions here in the Lagrangian or Noether tags.  See if you can figure out their answers, then read the answers people have provided to compare.
If you thought that the Lagrangian approach was wrong, then you might want someone to convince you otherwise.  But if you just don't feel comfortable with it yet, you'd be robbing yourself of a great pleasure by not taking the time to learn its intricacies.
Finally, your question is very similar to this one, so check out the answers there as well.


Question:
I'm about to start working on a software library of numerical ODE solvers, and I'm struggling with how to formulate tests for the solver implementations. My ambition is that the library, eventually, will include solvers for both nonstiff and stiff problems, and at least one implicit solver (more or less on par with the capabilities of the ode routines in Matlab), so the test methodology needs to reflect the various types of problems and criteria for different solvers.
My problem now is that I don't know where to begin with this testing. I can think of a few different ways to test the output of an algorithm:

Test for a problem that has an analytical solution, and check that the numerical solution is within tolerance levels for all the returned data points. This requires knowledge of a number of analytical problems which exhibit all the properties that I want the different solvers to work with (stiffness, implicit problems etc), which I don't have, at least not off the top of my head.
This method tests the results of a solver method. Thus, there is no guarantee that the solver actually works, just that it works for the given test problem. Therefore, I suspect a large number of test problems is needed to confidently verify that the solver works.
Manually calculate the solution for a few time steps using the algorithms I intend to implement, and then do the same with the solvers and check that the results are the same. This requires no knowledge of the true solution to the problem, but in turn requires quite a lot of hands-on work.
This method, on the other hand, only tests the algorithm, which is fine by me - if someone else has proven that 4th order Runge-Kutta works, I don't feel a desperate need to. However, I do worry that it will be very cumbersome to formulate test cases, as I don't know a good method to generate the test data (except maybe by hand, which will be a lot of work...).

Both the above methods have serious limitations for me with my current knowledge - I don't know a good set of test problems for the first one, and I don't know a good method of generating test data for the second.
Is there other ways to verify numerical ODE solvers? Are there other criteria on the implementations that should be verified? Are there any good (free) resources on testing ODE solvers out there1?
EDIT:
Since this question is very broad, I want to clarify a little. The test suite I want to create will fill two main purposes:

Verifying that the solvers work as expected, for the problems they're intended to solve. In other words, a solver for non-stiff problems is allowed to go bananas on a stiff problem, but should perform well on non-stiff problems. Also, if there are other solvers in the library that offer higher accuracy, it might not be necessary to enforce very accurate results - just "accurate enough". Thus, part of my question is what tests should be used for what solvers; or, at least, how one should reason to decide that.
Sanity test upon installation of the library. These test need not (should not) be elaborate or time-consuming; just the very basics that can be run in under 5 seconds, but that will alert the user if something is off-the-charts weird. Thus, I also need a way to construct tests that are very simple, but that still tell me something about the state of the library.

1 Yes, I've been Googling my eyes out, but most of what I find is lecture notes with very trivial examples, with the notable exception of the CWI ODE test set from Bari which I don't know if, or how, I could use for my purposes, since it treats much more sophisticated solvers than the ones I want to test...

This is a very broad question and I am going to give you some things to think about (some are already included in your post, but they are repeated here for completeness).
Scope of Problems

You need to define the interface of how to specify problems.
Are you going to allow parameters that can be fixed or can vary for solutions?
Are you going to allow perturbation parameters to slightly perturb problems and see if they are still solvable (for example, an $\epsilon$ parameter to be defined anywhere) in a specific problem?
Are you going to allow infinite precision?
Are you going to test for speed and sensitivity to numerical precision?
Have you chosen two (maybe more) libraries that already exist to compare results?
How will you choose stopping criteria, will you use various methods and let the user select or define their own?
Are you going to measure error using various measures and allow the user to turn those on and off?
Have you looked at the professional packages like Computer-Algebra-Systems (CAS) and understand all of the options they allow?
Are you going to allow displaying of results and/or comparisons and/or plots?

Problem Recommendations

You need to write a test specification defining the source of problems, the scope of how problems were tested, capturing results and metrics of running the routines.
I would certainly look to other libraries already out there for the problems they are using (maybe test files).
I would go to college libraries and go through books on ODEs and pull out problems of all types, those with known closed form or numeric only solutions.
Case 1: We want as many variations of closed form solution problems as we can get in order to compare exact versus numerical results.
Case 2: I would go to every numerical analysis book I can find and capture the worked examples and duplicate them. I would additionally capture the problem sets, particularly the ones that have some pathology that exist in most books (sensitivity to this or that types).
Case 3: I would go to different branches of applied math like Physics, Ecology, Biology, Economics, et. al and capture problems from each of those domains to validate that your specification language for problems allows for such examples.
Case 4: I would research papers/journals that contain the most useful examples where the particular author had to modify a particular approach to account for some pathology or weirdness or hardness.
Case 5: Search the web for additional examples. For stiff, see the references here and peruse them ALL to ferret out test problems. Here are some MATLAB examples to peruse.

This is not unique. If you look at the book "Numerical Methods for Unconstrained Optimization and Nonlinear Equations" by Dennis and Schnabel, Appendix B, "Test Problems", you can see how they did it. After developing one of the most beautiful set of algorithms write ups I have ever seen, they threw a collection of problems at it that made if go nuts. You had to tweak here and there! They included five very different and pathological problems that strained the capabilities of the solvers. This has taught me that we can continue to throw problems at algorithms that they are incapable of handling for a host of reasons. Note, they even borrowed this set of problems from More', Garbow and Hillstrom (you can also look up that reference and perhaps there are others you can use as a guide).
In other words, this is not a trivial task. You need Known-Answer-test cases that always allow you to test the validity of updates and don't break things. That is, a repeatable and extensive set of problems from low to high, from easy to hard, from possible to impossible, ... You also need a collection of problems that your solvers cannot handle in order to truly understand its limitations.


Question:
From Wikipedia, there are three interpretations of the degrees of freedom of a statistic:

In statistics, the number of degrees of freedom is the number of
  values in the final calculation of a statistic that are free to vary.
Estimates of statistical parameters can be based upon different
  amounts of information or data. The number of independent pieces of
  information that go into the estimate of a parameter is called the
  degrees of freedom (df). In general, the degrees of freedom of an
  estimate of a parameter is equal to the number of independent scores
  that go into the estimate minus the number of parameters used as
  intermediate steps in the estimation of the parameter itself (which,
  in sample variance, is one, since the sample mean is the only
  intermediate step).
Mathematically, degrees of freedom is the dimension of the domain of a
  random vector, or essentially the number of 'free' components: how
  many components need to be known before the vector is fully
  determined.

The bold words are what I don't quite understand. If possible, some mathematical formulations will help clarify the concept.
Also do the three interpretations agree with each other?

This is a subtle question.  It takes a thoughtful person not to understand those quotations!  Although they are suggestive, it turns out that none of them is exactly or generally correct.  I haven't the time (and there isn't the space here) to give a full exposition, but I would like to share one approach and an insight that it suggests.
Where does the concept of degrees of freedom (DF) arise?  The contexts in which it's found in elementary treatments are:

The Student t-test and its variants such as the Welch or Satterthwaite solutions to the Behrens-Fisher problem (where two populations have different variances).
The Chi-squared distribution (defined as a sum of squares of independent standard Normals), which is implicated in the sampling distribution of the variance.
The F-test (of ratios of estimated variances).
The Chi-squared test, comprising its uses in (a) testing for independence in contingency tables and (b) testing for goodness of fit of distributional estimates.

In spirit, these tests run a gamut from being exact (the Student t-test and F-test for Normal variates) to being good approximations (the Student t-test and the Welch/Satterthwaite tests for not-too-badly-skewed data) to being based on asymptotic approximations (the Chi-squared test).  An interesting aspect of some of these is the appearance of non-integral "degrees of freedom" (the Welch/Satterthwaite tests and, as we will see, the Chi-squared test).  This is of especial interest because it is the first hint that DF is not any of the things claimed of it.
We can dispose right away of some of the claims in the question.  Because "final calculation of a statistic" is not well-defined (it apparently depends on what algorithm one uses for the calculation), it can be no more than a vague suggestion and is worth no further criticism.  Similarly, neither "number of independent scores that go into the estimate" nor "the number of parameters used as intermediate steps" are well-defined.
"Independent pieces of information that go into [an] estimate" is difficult to deal with, because there are two different but intimately related senses of "independent" that can be relevant here.  One is independence of random variables; the other is functional independence.  As an example of the latter, suppose we collect morphometric measurements of subjects--say, for simplicity, the three side lengths $X$, $Y$, $Z$, surface areas $S=2(XY+YZ+ZX)$, and volumes $V=XYZ$ of a set of wooden blocks.  The three side lengths can be considered independent random variables, but all five variables are dependent RVs.  The five are also functionally dependent because the codomain (not the "domain"!) of the vector-valued random variable $(X,Y,Z,S,V)$ traces out a three-dimensional manifold in $\mathbb{R}^5$.  (Thus, locally at any point $\omega\in\mathbb{R}^5$, there are two functions $f_\omega$ and $g_\omega$ for which $f_\omega(X(\psi),\ldots,V(\psi))=0$ and $g_\omega(X(\psi),\ldots,V(\psi))=0$ for points $\psi$ "near" $\omega$ and the derivatives of $f$ and $g$ evaluated at $\omega$ are linearly independent.)  However--here's the kicker--for many probability measures on the blocks, subsets of the variables such as $(X,S,V)$ are dependent as random variables but functionally independent.
Having been alerted by these potential ambiguities, let's hold up the Chi-squared goodness of fit test for examination, because (a) it's simple, (b) it's one of the common situations where people really do need to know about DF to get the p-value right and (c) it's often used incorrectly.  Here's a brief synopsis of the least controversial application of this test:

You have a collection of data values $(x_1, \ldots, x_n)$, considered as a sample of a population.
You have estimated some parameters $\theta_1, \ldots, \theta_p$ of a distribution. For example, you estimated the mean $\theta_1$ and standard deviation $\theta_2 = \theta_p$ of a Normal distribution, hypothesizing that the population is normally distributed but not knowing (in advance of obtaining the data) what $\theta_1$ or $\theta_2$ might be.
In advance, you created a set of $k$ "bins" for the data.  (It may be problematic when the bins are determined by the data, even though this is often done.)  Using these bins, the data are reduced to the set of counts within each bin.  Anticipating what the true values of $(\theta)$ might be, you have arranged it so (hopefully) each bin will receive approximately the same count.  (Equal-probability binning assures the chi-squared distribution really is a good approximation to the true distribution of the chi-squared statistic about to be described.)
You have a lot of data--enough to assure that almost all bins ought to have counts of 5 or greater.  (This, we hope, will enable the sampling distribution of the $\chi^2$ statistic to be approximated adequately by some $\chi^2$ distribution.)

Using the parameter estimates, you can compute the expected count in each bin.  The Chi-squared statistic is the sum of the ratios
$$\frac{(\text{observed}-\text{expected})^2}{\text{expected}}.$$
This, many authorities tell us, should have (to a very close approximation) a Chi-squared distribution.  But there's a whole family of such distributions.  They are differentiated by a parameter $\nu$ often referred to as the "degrees of freedom."  The standard reasoning about how to determine $\nu$ goes like this

I have $k$ counts.  That's $k$ pieces of data.  But there are (functional) relationships among them.  To start with, I know in advance that the sum of the counts must equal $n$.  That's one relationship.  I estimated two (or $p$, generally) parameters from the data.  That's two (or $p$) additional relationships, giving $p+1$ total relationships.  Presuming they (the parameters) are all (functionally) independent, that leaves only $k-p-1$ (functionally) independent "degrees of freedom": that's the value to use for $\nu$.

The problem with this reasoning (which is the sort of calculation the quotations in the question are hinting at) is that it's wrong except when some special additional conditions hold.  Moreover, those conditions have nothing to do with independence (functional or statistical), with numbers of "components" of the data, with the numbers of parameters, nor with anything else referred to in the original question.
Let me show you with an example.  (To make it as clear as possible, I'm using a small number of bins, but that's not essential.)  Let's generate 20 independent and identically distributed (iid) standard Normal variates and estimate their mean and standard deviation with the usual formulas (mean = sum/count, etc.).  To test goodness of fit, create four bins with cutpoints at the quartiles of a standard normal: -0.675, 0, +0.657, and use the bin counts to generate a Chi-squared statistic.  Repeat as patience allows; I had time to do 10,000 repetitions.
The standard wisdom about DF says we have 4 bins and 1+2 = 3 constraints, implying the distribution of these 10,000 Chi-squared statistics should follow a Chi-squared distribution with 1 DF.  Here's the histogram:

The dark blue line graphs the PDF of a $\chi^2(1)$ distribution--the one we thought would work--while the dark red line graphs that of a $\chi^2(2)$ distribution (which would be a good guess if someone were to tell you that $\nu=1$ is incorrect).  Neither fits the data.
You might expect the problem to be due to the small size of the data sets ($n$=20) or perhaps the small size of the number of bins.  However, the problem persists even with very large datasets and larger numbers of bins: it is not merely a failure to reach an asymptotic approximation.
Things went wrong because I violated two requirements of the Chi-squared test:

You must use the Maximum Likelihood estimate of the parameters.  (This requirement can, in practice, be slightly violated.)
You must base that estimate on the counts, not on the actual data!  (This is crucial.)

The red histogram depicts the chi-squared statistics for 10,000 separate iterations, following these requirements.  Sure enough, it visibly follows the $\chi^2(1)$ curve (with an acceptable amount of sampling error), as we had originally hoped.
The point of this comparison--which I hope you have seen coming--is that the correct DF to use for computing the p-values depends on many things other than dimensions of manifolds, counts of functional relationships, or the geometry of Normal variates.  There is a subtle, delicate interaction between certain functional dependencies, as found in mathematical relationships among quantities, and distributions of the data, their statistics, and the estimators formed from them.  Accordingly, it cannot be the case that DF is adequately explainable in terms of the geometry of multivariate normal distributions, or in terms of functional independence, or as counts of parameters, or anything else of this nature.
We are led to see, then, that "degrees of freedom" is merely a heuristic that suggests what the sampling distribution of a (t, Chi-squared, or F) statistic ought to be, but it is not dispositive.  Belief that it is dispositive leads to egregious errors.  (For instance, the top hit on Google when searching "chi squared goodness of fit" is a Web page from an Ivy League university that gets most of this completely wrong!  In particular, a simulation based on its instructions shows that the chi-squared value it recommends as having 7 DF actually has 9 DF.)
With this more nuanced understanding, it's worthwhile to re-read the Wikipedia article in question: in its details it gets things right, pointing out where the DF heuristic tends to work and where it is either an approximation or does not apply at all.

A good account of the phenomenon illustrated here (unexpectedly high DF in Chi-squared GOF tests) appears in Volume II of Kendall & Stuart, 5th edition.  I am grateful for the opportunity afforded by this question to lead me back to this wonderful text, which is full of such useful analyses.

Edit (Jan 2017)
Here is R code to produce the figure following "The standard wisdom about DF..."
#
# Simulate data, one iteration per column of `x`.
#
n <- 20
n.sim <- 1e4
bins <- qnorm(seq(0, 1, 1/4))
x <- matrix(rnorm(n*n.sim), nrow=n)
#
# Compute statistics.
#
m <- colMeans(x)
s <- apply(sweep(x, 2, m), 2, sd)
counts <- apply(matrix(as.numeric(cut(x, bins)), nrow=n), 2, tabulate, nbins=4)
expectations <- mapply(function(m,s) n*diff(pnorm(bins, m, s)), m, s)
chisquared <- colSums((counts - expectations)^2 / expectations)
#
# Plot histograms of means, variances, and chi-squared stats.  The first
# two confirm all is working as expected.
#
mfrow <- par("mfrow")
par(mfrow=c(1,3))
red <- "#a04040"  # Intended to show correct distributions
blue <- "#404090" # To show the putative chi-squared distribution
hist(m, freq=FALSE)
curve(dnorm(x, sd=1/sqrt(n)), add=TRUE, col=red, lwd=2)
hist(s^2, freq=FALSE)
curve(dchisq(x*(n-1), df=n-1)*(n-1), add=TRUE, col=red, lwd=2)
hist(chisquared, freq=FALSE, breaks=seq(0, ceiling(max(chisquared)), 1/4),
     xlim=c(0, 13), ylim=c(0, 0.55),
     col="#c0c0ff", border="#404040")
curve(ifelse(x <= 0, Inf, dchisq(x, df=2)), add=TRUE, col=red, lwd=2)
curve(ifelse(x <= 0, Inf, dchisq(x, df=1)), add=TRUE, col=blue, lwd=2)
par(mfrow=mfrow)


Question:
Consider this picture of sun beams streaming onto the valley through the clouds.

Given that the valley is only (at a guess) 3km wide, with simple trigonometry and the angles of the beams, this gives the result that the position of the light source is being a few tens of km away at most.
What is wrong with the analysis?

This picture (source) should pretty much answer your question:

The train's destination is not above the ground, but rather far away, and perspective means that the tracks appear not to be parallel but instead to converge to the vanishing point.
The same applies to the beams of light above them. The Sun is very far away and the beams are pretty much parallel, but they're pointing towards you, and perspective makes them appear to converge towards the vanishing point - which in this case is the Sun's location in the sky.
The technical term for these beams is "crepuscular rays." Occasionally, when the Sun is very low on the horizon, you can see "anticrepuscular rays," where the beams seem to converge to a different point on the opposite side of the sky to the Sun. Here's an example: (source)

This happens for the same reason - the rays are really parallel, and there's another vanishing point in the opposite direction from the Sun.


Question:
I've found on multiple sites that convolution and cross-correlation are similar (including the tag wiki for convolution), but I didn't find anywhere how they differ.
What is the difference between the two? Can you say that autocorrelation is also a kind of a convolution?

The only difference between cross-correlation and convolution is a time reversal on one of the inputs. Discrete convolution and cross-correlation are defined as follows (for real signals; I neglected the conjugates needed when the signals are complex):
$$
x[n] * h[n] = \sum_{k=0}^{\infty}h[k] x[n-k]
$$
$$
corr(x[n],h[n]) = \sum_{k=0}^{\infty}h[k] x[n+k]
$$
This implies that you can use fast convolution algorithms like overlap-save to implement cross-correlation efficiently; just time reverse one of the input signals first. Autocorrelation is identical to the above, except $h[n] = x[n]$, so you can view it as related to convolution in the same way.
Edit: Since someone else just asked a duplicate question, I've been inspired to add one more piece of information: if you implement correlation in the frequency domain using a fast convolution algorithm like overlap-save, you can avoid the hassle of time-reversing one of the signals first by instead conjugating one of the signals in the frequency domain. It can be shown that conjugation in the frequency domain is equivalent to reversal in the time domain.


Question:
If I have a signal that is time limited, say a sinusoid that only lasts for $T$ seconds, and I take the FFT of that signal, I see the frequency response. In the example this would be a spike at the sinusoid's main frequency.
Now, say I take that same time signal and delay it by some time constant and then take the FFT, how do things change? Is the FFT able to represent that time delay?
I recognize that a time delay represents a $\exp(-j\omega t)$ change in the frequency domain, but I'm having a hard time determining what that actually means.
Practically speaking, is the frequency domain an appropriate place to determine the time delay between various signals?

The discrete Fourier transform (DFT), commonly implemented by the fast Fourier transform (FFT), maps a finite-length sequence of discrete time-domain samples into an equal-length sequence of frequency-domain samples. The samples in the frequency domain are in general complex numbers; they represent coefficients that can be used in a weighted sum of complex exponential functions in the time domain to reconstruct the original time-domain signal.
These complex numbers represent an amplitude and phase that is associated with each exponential function. Thus, each number in the FFT output sequence can be interpreted as:
$$
X[k] = \sum_{n=0}^{N-1} x[n] e^{\frac{-j 2 \pi n k}{N}} = A_k e^{j \phi_k}
$$
You can interpret this as follows: if you want to reconstruct x[n], the signal that you started with, you can take a bunch of complex exponential functions $e^{\frac{j 2 \pi n k}{N}}, k = 0, 1, \ldots, N-1$, weight each one by $X[k] = A_k e^{j \phi_k}$, and sum them. The result is exactly equal (within numerical precision) to $x[n]$. This is just a word-based definition of the inverse DFT.
So, speaking to your question, the various flavors of the Fourier transform have the property that a delay in the time domain maps to a phase shift in the frequency domain. For the DFT, this property is:
$$
x[n] \leftrightarrow X[k]
$$
$$
x[n-D] \leftrightarrow e^{\frac{-j2 \pi k D}{N}}X[k]
$$
That is, if you delay your input signal by $D$ samples, then each complex value in the FFT of the signal is multiplied by the constant $e^{\frac{-j2 \pi k D}{N}}$. It's common for people to not realize that the outputs of the DFT/FFT are complex values, because they are often visualized as magnitudes only (or sometimes as magnitude and phase).
Edit: I want to point out that there are some subtleties to this rule for the DFT due to its finiteness in time coverage. Specifically, the shift in your signal must be circular for the relation to hold; that is, when you delay $x[n]$ by $D$ samples, you need to wrap the last $D$ samples that were at the end of $x[n]$ to the front of the delayed signal. This wouldn't really match what you would see in a real situation where the signal just doesn't start until after the beginning of the DFT aperture (and is preceded by zeros, for example). You can always get around this by zero-padding the original signal $x[n]$ so that when you delay by $D$ samples, you just wrap around zeros to the front anyway. This relationship only applies to the DFT since it is finite in time; it's does not apply to the classic Fourier transform or discrete-time Fourier transform.


Question:
Many machine learning classifiers (e.g. support vector machines) allow one to specify a kernel. What would be an intuitive way of explaining what a kernel is?
One aspect I have been thinking of is the distinction between linear and non-linear kernels. In simple terms, I could speak of 'linear decision functions' an 'non-linear decision functions'. However, I am not sure if calling a kernel a 'decision function' is a good idea.
Suggestions?

Kernel is a way of computing the dot product of two vectors $\mathbf x$ and $\mathbf y$ in some (possibly very high dimensional) feature space, which is why kernel functions are sometimes called "generalized dot product".
Suppose we have a mapping $\varphi \, : \, \mathbb R^n \to \mathbb R^m$ that brings our vectors in $\mathbb R^n$ to some feature space $\mathbb R^m$. Then the dot product of $\mathbf x$ and $\mathbf y$ in this space is $\varphi(\mathbf x)^T \varphi(\mathbf y)$. A kernel is a function $k$ that corresponds to this dot product, i.e. $k(\mathbf x, \mathbf y) = \varphi(\mathbf x)^T \varphi(\mathbf y)$.
Why is this useful? Kernels give a way to compute dot products in some feature space without even knowing what this space is and what is $\varphi$.
For example, consider a simple polynomial kernel $k(\mathbf x, \mathbf y) = (1 + \mathbf x^T \mathbf y)^2$ with $\mathbf x, \mathbf y \in \mathbb R^2$. This doesn't seem to correspond to any mapping function $\varphi$, it's just a function that returns a real number. Assuming that $\mathbf x = (x_1, x_2)$ and $\mathbf y = (y_1, y_2)$, let's expand this expression:
$\begin{align}
k(\mathbf x, \mathbf y) & = (1 + \mathbf x^T \mathbf y)^2 = (1 + x_1 \, y_1  + x_2 \, y_2)^2 = \\
 & = 1 + x_1^2 y_1^2 + x_2^2 y_2^2 + 2 x_1 y_1 + 2 x_2 y_2 + 2 x_1 x_2 y_1 y_2
\end{align}$
Note that this is nothing else but a dot product between two vectors $(1, x_1^2, x_2^2, \sqrt{2} x_1, \sqrt{2} x_2, \sqrt{2} x_1 x_2)$ and $(1, y_1^2, y_2^2, \sqrt{2} y_1, \sqrt{2} y_2, \sqrt{2} y_1 y_2)$, and $\varphi(\mathbf x) = \varphi(x_1, x_2) = (1, x_1^2, x_2^2, \sqrt{2} x_1, \sqrt{2} x_2, \sqrt{2} x_1 x_2)$. So the kernel $k(\mathbf x, \mathbf y) = (1 + \mathbf x^T \mathbf y)^2 = \varphi(\mathbf x)^T \varphi(\mathbf y)$ computes a dot product in 6-dimensional space without explicitly visiting this space.
Another example is Gaussian kernel $k(\mathbf x, \mathbf y) = \exp\big(- \gamma \, \|\mathbf x - \mathbf y\|^2 \big)$. If we Taylor-expand this function, we'll see that it corresponds to an infinite-dimensional codomain of $\varphi$.
Finally, I'd recommend an online course "Learning from Data" by Professor Yaser Abu-Mostafa as a good introduction to kernel-based methods. Specifically, lectures "Support Vector Machines", "Kernel Methods" and "Radial Basis Functions" are about kernels.


Question:
This question was prompted by Can matter really fall through an event horizon?. Notoriously, if you calculate the Schwarzschild coordinate time for anything, matter or light, to reach the event horizon the result is infinite. This implies that the universe ages by an infinite time before someone falling into the black hole reaches the event horizon, so could that person see the universe age by an infinite time?
To be more precise, suppose the observer starts falling from rest at time $t = 0$ and some initial distance $r > r_s$. If we wait for some time $T$ then shine a light ray at the falling observer. Will the light ray always reach the falling observer before they cross the event horizon? If not, what is the formula for the longest time $T$ that we can wait and still be sure the ray will catch the observer? If $T$ is not bounded it implies that observer could indeed see the end of the universe.
I can think of a qualitative argument for an upper limit on $T$, but I'm not sure how sound my argument is. The proper time for the observer to fall to the event horizon is finite - call this $\tau$. The proper time for the light ray to reach the horizon is zero, therefore the light ray will reach the observer before they cross the event horizon only if $T < \tau$. Hence $T$ is bounded and the observer won't see the end of the universe.
I think a more rigorous approach would be to determine the equations of motion (in the Schwarzschild coordinates) for the falling observer and the light ray, and then find the condition for the light to reach the falling observer at some distance $\epsilon$ from the event horizon. Then take the limit as $\epsilon \rightarrow 0$. In principle this seems straightforward, but in practice the algebra rapidly defeated me. Even for a light ray the radial distance:time equation isn't closed form (Wolfram claims it needs the $W$ function) and for the falling observer the calculation is even harder.

I would recommend steering clear of Schwarzschild coordinates for these kind of questions. All the classical (i.e. firewall paradox aside) infinities having to do with the event horizon are due to poor coordinate choices. You want to use a coordinate system that is regular at the horizon, like Kruskal-Szekeres. Indeed, have a look at the Kruskal-Szekeres diagram:

(source: Wikipedia)
This is the maximally extended Schwarschild geometry, not a physical black hole forming from stellar collapse, but the differences shouldn't bother us for this question. Region I and III are asymptotically flat regions, II is the interior of the black hole and IV is a white hole. The bold hyperbolae in regions II and IV are the singularities. The diagonals through the origin are the event horizons. The origin (really a 2-sphere with angular coordinates suppressed) is the throat of a non-traversable wormhole joining the separate "universes" I and III. Radial light rays remain 45 degree diagonal lines on the Kruskal-Szekeres diagram. The dashed hyperbolae are lines of constant Schwarzschild $r$ coordinate, and the dashed radial rays are lines of constant $t$. You can see how the event horizon becomes a coordinate singularity where $r$ and $t$ switch roles.
Now if you draw a worldline from region I going into region II it becomes obvious that it crosses the horizon in finite proper time and, more importantly, the past light-cone of the event where it hits the singularity cannot possibly contain the whole spacetime. So the short answer to your question is no, someone falling into a black hole does not see the end of the universe. I don't know the formula you ask for for $T$, but in principle you can read it off from light rays on the diagram and just convert to whatever coordinate/proper time you want to use.


Question:
This is a frequently-asked question within the nanopore community. Oxford Nanopore currently claims that they are able to generate run yields of 10-15 gigabases (e.g. see here and here), and yet it's more common to see users only managing in the 1-5 gigabase range.
So why the big difference in yield?

I attended a talk by Josh Quick at PoreCampAU 2017, in which he discussed some common barriers to getting both good sequencing yield and long read length. It mostly boils down to being more careful with the sample preparation. Bear in mind that the MinION will still sequence a dirty sample, it will just be at a reduced yield. Here are my notes from that talk:

The hardest thing about MinION sequencing is getting the sample in the first place
There are lots of different sample types and extraction methods
You can't get longer reads than what you put in; shit in leads to shit out
DNA is very stable when not moving, but very sensitive to lateral damage
The phenol chloroform method of DNA extraction is very good, and can be used with a phase-locked gel to make extraction easier
A simple salt + alcohol extraction might be the best method for extraction (because it involves the least amount of work on the DNA)
EDTA (e.g. as found in TE buffer, and many extraction kits) is not compatible with the rapid kit
The most consistently good Nanopore runs produced by Josh's lab were 1D ligations runs on R9.4; the best overall run was a phenol-chloroform extraction + rapid kit
John Tyson can tune himself out of a low-yield hole (via software)
Getting small numbers of short reads is very important
Suggested (and mostly untested) purification techniques: spin column (60-100kb); ethanol extraction (100-150kb), dialysis (150-250kb); low melting-point agarose plug (~1Mb, DNA extraction in situ)
The nanopore protocol input is in nanograms, but should really be stated as molarity; the kit expects about 0.2 pmol input
Picture molecules tethered to the surface of the membrane. You can then see that the flow cell density is independent of the sequence length
Tapestation, Qubit and Nanodrop are all a good idea; a DNA sample that can pass all three tests will work well: no short-length shoulders by Tapestation, sufficient DNA by Qubit, high purity by Nanodrop
RNA can interfere with sequencing; digesting RNA is recommended
Freezing DNA is a really bad idea. The ice crystals are very good at chopping DNA up into small pieces
DNA that is kept in the fridge is remarkably stable; can be kept for over two years (and probably indefinitely)

For us, our best cDNA sequencing run on MinION produced over 15M reads in June 2020. We've since shifted over to doing cDNA sequencing on PromethION flow cell (using a P2 Solo), and our best so far with that run was 89M reads.


Question:
I need to find the squares in an image using OpenCV (no problem in matlab or any other, generally what i expect are some ideas).
Consider the test image below :

I need to find those coloured squares in above image accurately (not the white long strips).
What I have done :

I applied the common method (which comes with OpenCV samples), ie find contours in all color planes, approximate it and check for number of elements=4. It works to some extend that, few squares are detected, especially the dark ones.
Next step i did was prediction. ie this arrangement is fixed. So, if some are obtained, I can predict remaining ones. It also worked to some further extend. But accuracy was very bad.

But I feel prediction is not a good method here and it doesn't always provide accurate answers as given by the first step.
What I need :
1) Is there any other better methods to detect these squares more accurately? Or multiple methods?
One important point is that, time is not a problem here. Algorithm can be slow, it doesn't matter. But accuracy is the major criteria.
Sometimes, images can be much more blurry.
And one of the major problem I faced is that some squares have almost similar color as that of background (check column 3 first and second squares).
Looking for ideas, thanks in advance
UPDATE :
Below is the maximum accurate result I got :

Of course, the result image is resized a little bit.
UPDATE 2 :
I have given a much more better solution in my answer below:

A first attempt using Matlab:
im = imread('squares.jpg');
im2 = rgb2gray(im);

se = strel('disk', 15);

for i = 1:16;
    t = 60+i*5; % try out a range of bw thresholds to see what works best
    labelled = bwlabel(im2>t); % label regions in the BW image
    closed = imclose(labelled, se); % close small regions
    cleared = imclearborder(~closed,4); % clear regions touching the border
    subplot(4,4,i);
    imshow(cleared);
    title(['T = ' num2str(t)]);
end

Results in the following regions:

As you can see, selecting the threshold that results in the highest number of regions (T=120) would already give 7 correct locations, some merged locations, one false positive and two false negatives.
This was a fairly simple attempt but I think it shows that the approach works. Adding some stuff to break up elongated regions, or doing this for each color channel separately are just a couple of the things you could do to improve on this.
It would also help if you provided a few more test images.


Question:
A couple of colleagues suggested in a discussion that the virus that causes COVID-19 appears to be made by humans, since nature could not have produced such an efficient virus — that spreads so fast and whose patients are contagious quite some time before showing signs of infection.
Since my knowledge of biology is very limited, my only counterargument for such a conspiracy theory was along the following lines:

there is a consensus that the most probable source of the first infection was in an animal market in China.
since that animal market was actually composed of a plethora of animals belonging to various species (mixed with humans), a virus had a bigger chance of evolving a mutation that might infect an individual from another species (a thing that is way less unlikely in the wild since many of those animals do not sit close to each others or next to humans).

Clearly, I have made a little story that might be quite far away from how SARS-CoV-2 infected humans, so I am interested in a scientific arguments to support my cause.
Question: What are the main scientific arguments that can be used to debunk COVID-19 being engineered by humans?
Answers that also include explanations more accessible to laymen are greatly welcomed.

At the moment, there is very little scientific literature about this, but I found two papers that address the problem and are fairly easy to understand. You can find them in the references. Reference 1 is probably the most interesting and is the basis for this answer.
Edit: It is also interesting to read reference 2 on the origin of SARS-CoV-2; the article also addresses some of the conspiracy theories.
As far as I can see, there are a few major points taken up by conspiracy theories.
1. SARS-CoV-2 leaked from a lab in which research on the Bat CoV (RaTG13) was done:
Unlikely, since the viruses share only around 96% sequence homology, which translates into more than 1100 sites where the sequence of SARS-CoV-2 viruses is different from RaTG13. The mutations are distributed throughout the viral genome in a natural evolutionary pattern, making it highly unlikely that SARS-CoV-2 is a direct descendant from RaTG13. For comparison, the original SARS-CoV and the intermediate host palm civet SARS-like CoV from which it originated shared 99.8% sequence homology, showing a much closer relation.
2. The S (spike) protein from bat SARS-CoV cannot be used to enter human cells via the human ACE2 receptor and therefore has been adapted in the lab:
This is untrue, since a 2013 study of a novel bat coronavirus was published showing the ability of the virus to enter cells via the ACE2 receptor. See reference 3 for details.
3. The spike protein of SARS-CoV contains a unique inserted sequence (1378 bp) located in the middle of its spike glycoprotein gene that had no match in other coronaviruses:
As shown in reference 4, the sequence comparison of the SARS-CoV-2 with closely related other coronaviruses shows that this sequence is not unique to the new virus but is already present in older strains. It shows some difference due to inserted mutations.
4. The claim that SARS-CoV-2 contains four insertions from HIV-1:
The paper claiming this has now been retracted due to severe criticism, and additionally a renowned HIV expert published an analysis (reference 5) demonstrating that the HIV-1 claimed insertions are random rather than targeted.
5. The claim that the SARS-CoV-2 virus is completely man-made:
To design such a "weapon grade" virus in the lab, the design would usually start from a known virus backbone and then introduce logical changes (for example, complete genes from other viruses). This cannot be seen in the genome of the virus; rather, you see randomly distributed changes throughout the genome coming from virus evolution and not directed cloning. It is more likely that this virus originates from the recombination of a bat CoV (to which it is closely, but not directly related) and another, not yet known CoV in an intermediate host, like the palm civet for the 2003 CoV.
References:

No credible evidence supporting claims of the laboratory engineering
of SARS-CoV-2
The proximal origin of SARS-CoV-2
Isolation and characterization of a bat SARS-like coronavirus that
uses the ACE2 receptor
Is SARS-CoV-2 originated from laboratory? A rebuttal to the claim of
formation via laboratory recombination
HIV-1 did not contribute to the 2019-nCoV genome


Question:
I want to modify a dense square transition matrix in-place by changing the order of several of its rows and columns, using python's numpy library.  Mathematically this corresponds to pre-multiplying the matrix by the permutation matrix P and post-multiplying it by P^-1 = P^T, but this is not a computationally reasonable solution.
Right now I am manually swapping rows and columns, but I would have expected numpy to have a nice function f(M, v) where M has n rows and columns, and v has n entries, so that f(M, v) updates M according to the index permutation v.  Maybe I am just failing at searching the internet.
Something like this might be possible with numpy's "advanced indexing" but my understanding is that such a solution would not be in-place.  Also for some simple situations it may be sufficient to just separately track an index permutation, but this is not convenient in my case.
Added:
Sometimes when people talk about permutations, they only mean the sampling of random permutations, for example as part of a procedure to obtain p-values in statistics.  Or they mean counting or enumerating all possible permutations.  I'm not talking about these things.
Added:
The matrix is small enough to fit into desktop RAM but big enough that I do not want to copy it thoughtlessly.  Actually I would like to use matrices as large as possible, but I don't want to deal with the inconvenience of not being able to hold them in RAM, and I do O(N^3) LAPACK operations on the matrix which would also limit the practical matrix size.  I currently copy matrices this large unnecessarily, but I would hope this could be easily avoided for permutation.

According to the docs, there is no in-place permutation method in numpy, something like ndarray.sort.
So your options are (assuming that M is a $N\times N$ matrix and p the permutation vector)

implementing your own algorithm in C as an extension module (but in-place algorithms are hard, at least for me!)
$N$ memory overhead
for i in range(N):
    M[:,i] = M[p,i]
for i in range(N):
    M[i,:] = M[i,p]

$N^2$ memory overhead
M[:,:] = M[p,:]
M[:,:] = M[:,p]

Hope that these suboptimal hacks are useful.


Question:
Question:
"Certain properties of a programming language may require that the only way to get the code written in it be executed is by interpretation. In other words, compilation to a native machine code of a traditional CPU is not possible. What are these properties?"
Compilers: Principles and Practice by Parag H. Dave and Himanshu B. Dave (May 2, 2012)
The book gives no clue about the answer. I tried to find the answer on Concepts of Programming Languages (SEBESTA), but to no avail. Web searches were of little avail too. Do you have any clue?

The distinction between interpreted and compiled code is probably a
fiction, as underlined by Raphael's comment:
the claim seems to be trivially wrong without further assumptions: if there is
an interpreter, I can always bundle interpreter and code in one executable ...

The fact is that code is always interpreted, by software, by hardware
or a combination of both, and the compiling process cannot tell which
it will be.
What you perceive as compilation is a translation process from one
language $S$ (for source) to another language $T$ (for target). And, the
interpreter for $S$ is usually different from the interpreter for $T$.
The compiled program is translated from one syntactic form $P_S$ to
another syntactic form $P_T$, such that, given the intended semantics
of the languages $S$ and $T$, $P_S$ and $P_T$ have the same
computational behavior, up to a few things that you are usually trying
to change, possibly to optimize, such as complexity or simple efficiency (time, space,
surface, energy consumption). I am trying not to talk of functional equivalence, as it would require precise definitions.
Some compilers have been actually used simply to reduce the size of
the code, not to "improve" execution. This was the case for language used in the Plato system (though they did not call it compiling).
You may consider your code fully compiled if, after the compiling
process, you no longer need the interpreter for $S$. At least, that is
the only way I can read your question, as an engineering rather than
theoretical question (since, theoretically, I can always rebuild the
interpreter).
One thing that may raise problem, afaik, is meta-circularity. That
is when a program will manipulate syntactic structures in its own source
language $S$, creating program fragment that are then intepreted as if
they had been part of the original program. Since you can produce
arbitrary program fragments in the language $S$ as the result of arbitrary computation manipulating meaningless syntactic fragments, I would guess you can
make it nearly impossible (from an engineering point of view) to
compile the program into the language $T$, so that it now generate
fragments of $T$. Hence the interpreter for $S$ will be needed, or at
least the compiler from $S$ to $T$ for on-the-fly compiling of
generated fragments in $S$ (see also this document).
But I am not sure how this can be formalized properly (and do not have
time right now for it). And impossible is a big word for an issue that is not formalized.
Futher remarks
Added after 36 hours. You may want to skip this very long sequel.
The many comments to this question show two views of the problem: a
theoretical view that see it as meaningless, and an engineering view
that is unfortunately not so easily formalized.
There are many ways to look at interpretation and compilation, and I
will try to sketch a few. I will attempt to be as informal as I can manage
The Tombstone Diagram
One of the early formalization (early 1960s to late 1990) is the T or
Tombstone diagrams. These diagrams presented in composable graphical
elements the implementation language of the interpreter or compiler,
the source language being interpreted or compiled, and the target
language in the case of compilers. More elaborate versions can add
attributes. These graphic representations can be seen as axioms,
inference rules, usable to mechanically derive processor generation
from a proof of their existence from the axioms, à la Curry-Howard
(though I am not sure that was done in the sixties :).
Partial evaluation
Another interesting view is the partial evaluation paradigm. I am
taking a simple view of programs as a kind of function implementation
that computes an answer given some input data. Then an interpreter
$I_S$ for the language $S$ is a program that take a program $p_S$
written in $S$ and data $d$ for that program, and computes the result
according to the semantics of $S$. Partial evaluation is a technique
for specializing a program of two arguments $a_1$ and $a_2$, when only
one argument, say $a_1$, is known. The intent is to have a faster
evaluation when you finally get the second argument $a_2$. It is
especially useful if $a_2$ changes more often than $a_1$ as the cost
of partial evaluation with $a_1$ can be amortized on all the
computations where only $a_2$ is changing.
This is a frequent situation in algorithm design (often the topic of
the first comment on SE-CS), when some more static part of the data is
pre-processed, so that the cost of the pre-processing can be amortized
on all applications of the algorithm with more variable parts of the
input data.
This is also the very situation of interpreters, as the first argument
is the program to be executed, and is usually executed many times with
different data (or has subparts executed many times with different
data). Hence it become a natural idea to specialize an interpreter for
faster evaluation of a given program by partially evaluating it on
this program as first argument.  This may be seen as a way of
compiling the program, and there has been significant
research work on compiling by partial evaluation of a interpreter on
its first (program) argument.
The Smn theorem
The nice point about the partial evaluation approach is that it does
take its roots in theory (though theory can be a liar), notably in
Kleene's Smn theorem.  I am trying here to give an intuitive
presentation of it, hoping it will not upset pure theoreticians.
Given a Gödel numbering $\varphi$ of recursive functions, you can
view $\varphi$ as your hardware, so that given the Gödel number $p$
(read object code) of a program $\varphi_p$ is the function defined
by $p$ (i.e. computed by the object code on your hardware).
In its simplest form, the theorem is stated in wikipedia as follows
(up to a small change in notation):

Given a Gödel numbering $\varphi$ of recursive functions, there is a primitive recursive function $\sigma$ of two arguments with the following property: for every Gödel number $q$ of a partial computable function $f$ with two arguments, the expressions $\varphi_{\sigma(q,x)}(y)$ and $f(x,y)$ are defined for the same combinations of natural numbers $x$ and $y$, and their values are equal for any such combination. In other words, the following extensional equality of functions holds for every $x$:
      $\;\;\varphi_{\sigma(q,x)} \simeq \lambda y.\varphi_q(x,y).\,$

Now, taking $q$ as the interpreter $I_S$, $x$ as the source code of a
program $p_S$, and $y$ as the data $d$ for that program, we can write:
   $\;\;\varphi_{\sigma(I_S,p_S)} \simeq \lambda d.\varphi_{I_S}(p_S,d).\,$
$\varphi_{I_S}$ may be seen as the execution of the interpreter $I_S$
on the hardware, i.e., as a black-box ready to interpret programs
written in language $S$.
The function $\sigma$ may be seen as a function that specializes the
interpreter $I_S$ for the program $P_S$, as in partial evaluation.
Thus the Gödel number $\sigma(I_S,p_S)$ may be seen has object code that is
the compiled version of program $p_S$.
So the function $\;C_S = \lambda q_S.\sigma((I_S,q_S)$ may be seen as
a function that take as argument the source code of a program $q_S$
written in language $S$, and return the object code version for that
program. So $C_S$ is what is usually called a compiler.
Some conclusions
However, as I said: "theory can be a liar", or actually seem to be one. The problem is that we
know nothing of the function $\sigma$. There are actually many such
functions, and my guess is that the proof of the theorem may use a
very simple definition for it, which might be no better, from an
engineering point of view, than the solution proposed by Raphael: to
simply bundle the source code $q_S$ with the interpreter $I_S$. This
can always be done, so that we can say: compiling is always
possible.
Formalizing a more restrictive notion of what is a compiler would
require a more subtle theoretical approach. I do not know what may
have been done in that direction. The very real work done on partial
evaluation is more realistic from an engineering point of view. And
there are of course other techniques for writing compilers, including
extraction of programs from the proof of their specification, as
developed in the context of type-theory, based on the Curry-Howard
isomorphism (but I am getting outside my domain of competence).
My purpose here has been to show that Raphael's remark is not "crazy",
but a sane reminder that things are not obvious, and not even
simple. Saying that something is impossible is a strong statement
that does require precise definitions and a proof, if only to have a
precise understanding of how and why it is impossible. But building
a proper formalization to express such a proof may be quite difficult.
This said, even if a specific feature is not compilable, in the sense
understood by engineers, standard compiling techniques can always be
applied to parts of the programs that do not use such a feature, as is
remarked by Gilles' answer.
To follow on Gilles' key remarks that, depending on the language, some
thing may be done at compile-time, while other have to be done at
run-time, thus requiring specific code, we can see that the concept of
compilation is actually ill-defined, and is probably not definable in
any satisfactory way. Compilation is only an optimization process, as
I tried to show in the partial evaluation section, when I compared
it with static data preprocessing in some algorithms.
As a complex optimization process, the concept of compilation actually
belongs to a continuum. Depending on the characteristic of the
language, or of the program, some information may be available
statically and allow for better optimization. Others things have to be
postponed to run-time. When things get really bad, everything has to
be done at run-time at least for some parts of the program, and
bundling  source-code with the interpreter is all you can do. So this
bundling is just the low end of this compiling continuum. Much of the research on compilers is about finding ways to do statically what used to be done dynamically. Compile-time garbage collection seems a good example.
Note that saying that the compilation process should produce machine
code is no help. That is precisely what the bundling can do as the
interpreter is machine code (well, thing can get a bit more complex
with cross-compilation).


Question:
I understand the Fourier Transform which is a mathematical operation that lets you see the frequency content of a given signal. But now, in my comm. course, the professor introduced the Hilbert Transform.
I understand that it is somewhat linked to the frequency content given the fact that the Hilbert Transform is multiplying a FFT by $-j\operatorname{sign}(W(f))$ or convolving the time function with $1/\pi t$.
What is the meaning of the Hilbert transform? What information do we get by applying that transform to a given signal?

One application of the Hilbert Transform is to obtain a so-called Analytic Signal. For signal $s(t)$, its Hilbert Transform $\hat{s}(t)$ is defined as a composition:
$$s_A(t)=s(t)+j\hat{s}(t) $$
The Analytic Signal that we obtain is complex valued, therefore we can express it in exponential notation:
$$s_A(t)=A(t)e^{j\psi(t)}$$
where:
$A(t)$ is the instantaneous amplitude (envelope)
$\psi(t)$ is the instantaneous phase.

So how are these helpful?
The instantaneous amplitude can be useful in many cases (it is widely used for finding the envelope of simple harmonic signals). Here is an example for an impulse response:

Secondly, based on the phase, we can calculate the instantaneous frequency:
$$f(t)=\dfrac{1}{2\pi}\dfrac{d\psi}{dt}(t)$$
Which is again helpful in many applications, such as frequency detection of a sweeping tone, rotating engines, etc.

Other examples of usage include:

Sampling of narrowband signals in telecommunications (mostly using Hilbert filters).
Medical imaging.
Array processing for Direction of Arrival.
System response analysis.


Question: Peoples' ears can hear sound whose frequencies range from 20 Hz to 20 kHz. Based on the Nyquist theorem, the recording rate should be at least 40 kHz. Is it the reason for choosing 44.1 kHz?

It is true that, like any convention, the choice of 44.1 kHz is sort of a historical accident. There are a few other historical reasons.
Of course, the sampling rate must exceed 40 kHz if you want high quality audio with a bandwidth of 20 kHz.
There was discussion of making it 48.0 kHz (it was nicely congruent with 24 frame/second films and the ostensible 30 frames/second in North American TV), but given the physical size of 120 mm, there was a limit to how much data the CD could hold, and given that an error detection and correction scheme was needed and that requires some redundancy in data, the amount of logical data the CD could store (about 700 MB) is about half of the amount of physical data. Given all of that, at the rate of 48 kHz, we were told that it could not hold all of Beethoven's 9th, but that it could hold the entire 9th on one disc at a slightly slower rate.  So 48 kHz is out.
Still, why 44.1 and not 44.0 or 45.0 kHz or some nice round number?
Then at the time, there existed a product in the late 1970s called the Sony F1 that was designed to record digital audio onto readily-available video tape (Betamax, not VHS). That was at 44.1 kHz (or more precisely 44.056 kHz).  So this would make it easy to transfer recordings, without resampling and interpolation, from the F1 to CD or in the other direction.
My understanding of how it gets there is that the horizontal scan rate of NTSC TV was 15.750 kHz and 44.1 kHz is exactly 2.8 times that. I'm not entirely sure, but I believe what that means is that you can have three stereo sample pairs per horizontal line, and for every 5 lines, where you would normally have 15 samples, there are 14 samples plus one additional sample for some parity check or redundancy in the F1.  14 samples for 5 lines is the same as 2.8 samples per horizontal line and with 15,750 lines per second, that comes out to be 44,100 samples per second.
Now, since color TV was introduced, they had to bump down slightly the horizontal line rate to 15734 lines per second. That adjustment leads to the 44,056 samples per second in the Sony F1.


Question: Arthropods have 6 or more limbs and arthropods with 6 limbs appear to move faster than arthropods with 8 limbs so I wonder whether this might have something to do with fast and efficient locomotion. But, this is just a guess. I wonder what the official explanation is, if it exists.

Number of legs in terrestrial vertebrates
Not only do mammals have four legs but actually all terrestrial vertebrates (which include mammals) have four legs. There are slight exceptions though as some lineages have lost their legs. Typically snakes have no legs anymore. Apesteguia and Zaher (2006) discuss the evolution of snakes legs reduction and report a fossil of snakes with a robust sacrum. Cetaecea (whales and friends) have lost their hind legs but we can still spot them on the skeleton. See for example the orca (killer whale, easily recognizable to its teeth) on the picture below. Pay attention to the small bones below its vertebral column at the level on the left side of the picture.
I also want to draw attention to the importance of the definition of legs. I guess that we would call something a pair of legs if it is constructed using a similar developmental pathway than current existing legs. If we are using some broader definition, then a prehensile tail as found in some new world monkeys, for example, could be considered as a leg (but only a single leg, not a pair of legs obviously). A list of animals having a prehensile tail can be found here (Wikipedia).
Did you say Natural Selection?
I think (might be wrong) that you have too selectionist a view of evolution. What I mean is that you are wondering why mammals have four legs and you're looking for an explanation of the kind "because mammal have this kind of need of locomotion and for this purpose four is the most optimal number of legs". Consider the following sentence: "If there is a need, natural selection will find a way!". This sentence is wrong! Evolution is not that easy. This false view of evolution is sometimes referred to as panselectionist.
The reality is that it is not easy to evolve such a developmental pathway as drastic as having an extra pair of legs that are well integrated into the body of the carrier of this new trait. Such an individual would need a brain, a nerve code, a heart and some other features that are adapted to have extra legs. Also, assuming such a thing came to existence it is rather complicated to imagine how it could be selected for. To go slightly further, you have to realize that there are many stochastic processes in evolution (including mutation and random variation in reproductive success) and an organism is a piece of complex machinery and is not necessarily easily transformable to some other form that would be more efficient (have higher reproductive success). Often going from one form to another may involve a "valley crossing" meaning that if several mutations are needed, intermediate forms may have low reproductive success and therefore a high amount of genetic drift (stochasticity in reproductive success) to cross such valley of low reproductive success. See shifting balance theory. Finally, even if there is selection for another trait, it may take time for the mean trait in the population to shift especially if there is only little genetic variance. A complete discussion on why the sentence "If there is a need, natural selection will find a way!" is wrong would fill up a whole book.
Gould (1979) is a classic article on the subject and is very easy to read even for a layperson.
Why 4 legs?
Terrestrial vertebrates have four legs because they evolved from a fish ancestor that had four members that were not too far from actual legs (members that could "easily" evolve into legs). This is what we call a phylogenetic signal. The explanation is as simple and basic as that. You can have a look at the diversity of terrestrial vertebrates here (click on the branches).
Number of legs in invertebrates
Arthropoda (Spiders (and other chelicerata), insects (and other hexapods), crustaceans (crabs, shrimps…) and Myriapoda (millipedes) and Trilobite as well)) evolved from a common ancestor who had a highly segmented body. From this ancestor, many groups have fused some segments. In these taxa, each pair of legs is attached to a particular segment (I don't think the segments are still visible in spiders today). In insects, for example, all 6 legs are attached to the thorax but to 3 different segments of the thorax, the pro- meso and meta-thorax (see below).
As a side note, it is interesting to know that the wings in insects did not evolve from the legs (as it is the case in birds and bats). There are two competing hypotheses for the origin of insect wings. Wings either developed from gills or from sclerite (chitine plate, the hard part of the insect). When insect first wings, they actually evolved three pairs of wings (one on each segment of the thorax). At least one pair has then been lost in all modern species. In the diptera, a second pair of wings have been lost and are replaced by halteres, particularly easy to spot in craneflies (see below picture). In millipedes, the link between segmentation and legs is even more obvious (see picture below). You can have a look at the diversity of Arthropoda here (click on the branches).
Pictures

Update 1
Asking how likely it is for a given population to evolve a given trait is extremely hard to answer. There are two main issues: 1) a definition of the question issue and 2) a knowledge issue. When asking for a probability one always needs to state the a priori knowledge. If everything is known a priori, then there is nothing stochastic (outside quantum physics). So to answer the question one has to decide what we take for granted and what we don't. The second issue is a knowledge issue. We are far from having enough knowledge in protein biophysics (and many other fields)  to answer that question. There are so many parameters to take into account. I would expect that creating a third pair of legs would need major changes and therefore one mutation will never be enough in order to develop a third pair of legs. But, no I cannot cite you any reference for this, I am just guessing!
Following the wings example in insects. Insects have had three pairs of wings. While some mutation(s) prevented the expression of the third (the first actually) pair many of the genetic information for this third pair remain in the genotype of insects as they still use it for the two other pairs. Taking advantage of that, Membracidae (treehoppers) developed some features using a similar biochemical pathway than the one used to develop wings. Those structures are used as protection or batesian mimicry.
Update 2
Let's imagine that an extremely unlikely series of mutations occur that create some rodent with 6-legs. Let's imagine this rodent with six legs has a larger heart in order to pump blood to these extra legs and it has a brain that is adapted to using six legs and some changes in its nerve cord so that it can control its 3rd pair of legs. Will this rodent have higher reproductive success than other individuals in the population? Well… let's imagine that with its six legs, it can run faster or whatever and has a very high fitness. How would the offspring of a six-leg mother (or father) and a four-leg father (or mother) look like? Will it be able to reproduce? See the issue is that it is hard for such trait to come to existence because 1) it needs many steps (mutations) and 2) it is hard to imagine how it could be selected for. For those reasons, there exist no vertebrates with 6 fully functional legs.
Well, let's assume it does and in consequence, after 200 generations or so, the whole population is only made of 6-legged individuals. Maybe the species got extinct then and no fossil record has ever been found. This is possible. It is not because something has existed that we necessarily find something in the fossil record.