Question: What is the advantage gained by the substitution of thymine for uracil in DNA?  I have read previously that it is due to thymine being "better protected" and therefore more suited to the storage role of DNA, which seems fine in theory, but why does the addition of a simple methyl group make the base more well protected?

One major problem with using uracil as a base is that cytosine can be deaminated, which converts it into uracil. This is not a rare reaction; it happens around 100 times per cell, per day. This is no major problem when using thymine, as the cell can easily recognize that the uracil doesn't belong there and can repair it by substituting it by a cytosine again.

There is an enzyme, uracil DNA glycosylase, that does exactly that; it excises uracil bases from double-stranded DNA. It can safely do that as uracil is not supposed to be present in the DNA and has to be the result of a base modification.
Now, if we would use uracil in DNA it would not be so easy to decide how to repair that error. It would prevent the usage of this important repair pathway.
The inability to repair such damage doesn't matter for RNA as the mRNA is comparatively short-lived and any potential errors don't lead to any lasting damage. It matters a lot for DNA as the errors are continued through every replication. Now, this explains why there is an advantage to using thymine in DNA, it doesn't explain why RNA uses uracil. I'd guess it just evolved that way and there was no significant drawback that could be selected against, but there might be a better reason (more difficult biosynthesis of thymine, maybe?).
You'll find a bit more information on that in "Molecular Biology of the Cell" from Bruce Alberts et al. in the chapter about DNA repair (from page 267 on in the 4th edition).


Question:
In molecular orbital theory, the fact that a bonding and antibonding molecular orbital pair have different energies is accompanied by the fact that the energy by which the bonding is lowered is less than the energy by which antibonding is raised, i.e. the stabilizing energy of each bonding interaction is less than the destabilising energy of antibonding. How is that possible if their sum has to equal the energies of the combining atomic orbitals and conservation of energy has to hold true?

"Antibonding is more antibonding than bonding is bonding."

For example, the fact that $\ce{He2}$ molecule is not formed can be explained from its MO diagram, which shows that the number of electrons in antibonding and bonding molecular orbitals is the same, and since the destabilizing energy of the antibonding MO is greater than the stabilising energy of bonding MO, the molecule is not formed. This is the common line of reasoning you find at most places.

Mathematical Explanation
When examining the linear combination of atomic orbitals (LCAO) for the $\ce{H2+}$ molecular ion, we get two different energy levels, $E_+$ and $E_-$ depending on the coefficients of the atomic orbitals. The energies of the two different MO's are:
$$\begin{align}
E_+ &= E_\text{1s} + \frac{j_0}{R} - \frac{j' + k'}{1+S} \\
E_- &= E_\text{1s} + \frac{j_0}{R} - \frac{j' - k'}{1-S}
\end{align} $$
Note that $j_0 = \frac{e^2}{4\pi\varepsilon_0}$, $R$ is the internuclear distance, $S=\int \chi_\text{A}^* \chi_\text{B}\,\text{d}V$ the overlap integral, $j'$ is a coulombic contribution to the energy and $k'$ is a contribution to the resonance integral, and it does not have a classical analogue. $j'$ and $k'$ are both positive and $j' \gt k'$. You'll note that $j'-k' > 0$.
This is why the energy levels of $E_+$ and $E_-$ are not symmetrical with respect to the energy level of $E_\text{1s}$.
Intuitive Explanation
The intuitive explanation goes along the following line: Imagine two hydrogen nuclei that slowly get closer to each other, and at some point start mixing their orbitals. Now, one very important interaction is the coulomb force between those two nuclei, which gets larger the closer the nuclei come together. As a consequence of this, the energies of the molecular orbitals get shifted upwards, which is what creates the asymmetric image that we have for these energy levels.
Basically, you have two positively charged nuclei getting closer to each other. Now you have two options:

Stick some electrons between them.
Don't stick some electrons between them.

If you follow through with option 1, you'll diminish the coulomb forces between the two nuclei somewhat in favor of electron-nucleus attraction. If you go with method 2 (remember that the $\sigma^*_\text{1s}$ MO has a node between the two nuclei), the nuclei feel each other's repulsive forces more strongly.
Further Information
I highly recommend the following book, from which most of the information above stems:

Peter Atkins and Ronald Friedman, In Molecular Quantum Mechanics; $5^\text{th}$ ed., Oxford University Press: Oxford, United Kingdom, 2011 (ISBN-13: 978-0199541423).


Question:
Thinking about it: You would never find a "Grounded" multimeter as robust and useful if a path to ground through the multimeter were introduced, modifying the circuit's behaviour and possibly damaging the multimeter with currents.
Why are so many oscilloscopes earth referenced? Upon reading some educational material, a majority of the "common mistakes made by students" are placing the grounding clip incorrectly and causing poor results - when the o-scope is just being used as a fancy voltmeter!
I've heard of a Tek scope having an isolation transformer within.. however ignoring that, and taking in to account that newer DSOs may have plastic cases (isolated from you most importantly I would assume) could I just remove the earthing pin, and install a 1:1 AC transformer inbetween the o-scope and outlet and be on my merry way probing various hot/neutral/earthed sources with no worries about a path to ground any longer through it?

Oscilloscopes usually require significant power and are physically big.  Having a chassis that size, which would include exposed ground on the BNC connectors and the probe ground clips, floating would be dangerous.
If you have to look at waveforms in wall-powered equipment, it is generally much better to put the isolation transformer on that equipment instead of on the scope.  Once the scope is connected, it provides a ground reference to that part of the circuit so other parts could then be at high ground-referenced voltages, which could be dangerous.  However, you'll likely be more careful not to touch parts of the unit under test than the scope.
Scopes can also have other paths to ground that are easy to forget.  For example, the scope on my bench usually has a permanent RS-232 connection to my computer.  It would be easy to float the scope but forget about such things.  The scope would actually not be floating.  At best a fuse would pop when it is first connected to a wall powered unit under test in the wrong place.
Manufacturers could isolate the scope easily enough, but that probably opens them to liability problems.  In general, bench equipment is not isolated but hand-held equipment is.  If you really need to make isolated measurements often, you can get battery operated handheld scopes.


Question: Which is the fastest library for performing delaunay triangulation of sets with millions if 3D points? Are there also GPU versions available? From the other side, having the voronoi tessellation of the same set of points, would help (in terms of performance) for getting the delaunay triangulation?

For computing three-dimensional Delaunay triangulations (tetrahedralizations, really), TetGen is a commonly used library.
For your convenience, here's a little benchmark on how long it takes to compute the terehedralization of a number of random points from the unit cube.  For 100,000 points it takes 4.5 seconds on an old Pentium M.

(This was done with Mathematica's TetGen interface.  I don't know how much overhead it introduces.)
Regarding your other question: if you already have the Voronoi tessellation, then getting the Delaunay triangulation is a relatively simple transformation.


Question:
If you calculate the area of a rectangle, you just multiply the height and the width and get back the unit squared.
Example:
5cm * 10cm = 50cm²
In contrast, if you calculate the size of an image, you also multiply the height and the width, but you get back the unit - Pixel - just as it was the unit of the height and width before multiplying.
Example:
What you actually calculate is the following:
3840 Pixel * 2160 Pixel = 8294400 Pixel
What I would expect is:
3840 Pixel * 2160 Pixel = 8294400 Pixel²
Why is that the unit at multiplying Pixels is not being squared?

Because "pixel" isn't a unit of measurement: it's an object. So, just like a wall that's 30 bricks wide by 10 bricks tall contains 300 bricks (not bricks-squared), an image that's 30 pixels wide by 10 pixels tall contains 300 pixels (not pixels-squared).


Question:
I want to understand the difference between pipeline systems and workflow engines.
After reading A Review of Scalable Bioinformatics Pipelines I had a good overview of current bioinformatics pipelines. After some further research I found that there is collection of highly capable workflow engines. My question is then based on what I saw for argo. I would say I can be used as a bioinformatics pipeline as well.
So how do bioinformatics pipelines differ from workflow engines?

Great question! Note that from a prescriptive standpoint, the terms pipeline and workflow don't have any strict or precise definitions. But it's still useful to take a descriptive standpoint and discuss how the terms are commonly used in the bioinformatics community.
But before talking about pipelines and workflows, it's helpful to talk about programs and scripts. A program or script typically implements a single data analysis task (or set of related tasks). Some examples include the following.

FastQC, a program that checks NGS reads for common quality issues
Trimmomatic, a program for cleaning NGS reads
salmon, a program for estimating transcript abundance from NGS reads
a custom R script that uses DESeq2 to perform differential expression analysis

A pipeline or a workflow refers to a particular kind of program or script that is intended primarily to combine other independent programs or scripts. For example, I might want to write an RNA-seq workflow that executes Trimmomatic, FastQC, salmon, and the R script using a single command. This is particularly useful if I have to run the same command many times, or if the commands take a long time to run. It's very inconvenient when you have to babysit your computer and wait for step 3 to finish so that you can launch step 4!
So when does a program become a pipeline? Honestly, there are no strict rules. In some cases it's clear: the 10-line Python script I wrote to split Fasta files is definitely NOT a pipeline, but the 200-line Python script I wrote that does nothing but invoke 6 other bioinformatics programs definitely IS a pipeline. There are a lot of tools that fall in the middle: they may require running multiple steps in a certain order, or implement their own processing but also delegate processing to other tools. Usually nobody worries too much about whether it's "correct" to call a particular tool a pipeline.
Finally, a workflow engine is the software used to actually execute your pipeline/workflow. As mentioned above, general-purpose scripting languages like Bash, Python, or Perl can be used to implement workflows. But there are other languages that are designed specifically for managing workflows. Perhaps the earliest and most popular of these is GNU Make, which was originally intended to help engineers coordinate software compilation but can be used for just about any workflow. More recently there has been a proliferation of tools intended to replace GNU Make for numerous languages in a variety of contexts. The most popular in bioinformatics seems to be Snakemake, which provides a nice balance of simplicity (through shell commands), flexibility (through configuration), and power-user support (through Python scripting). Build scripts written for these tools (i.e., a Makefile or Snakefile) are often called pipelines or workflows, and the workflow engine is the software that executes the workflow.
The workflow engines you listed above (such as argo) can certainly be used to coordinate bioinformatics workflows. Honestly though, these are aimed more at the broader tech industry: they involve not just workflow execution but also hardware and infrastructure coordination, and would require a level of engineering expertise/support not commonly available in a bioinformatics setting. This could change, however, as bioinformatics becomes more of a "big data" endeavor.
As a final note, I'll mention a few more relevant technologies that I wasn't able to fit above.

Docker: managing a consistent software environment across multiple (potentially dozens or hundreds) of computers; Singularity is Docker's less popular step-sister
Common Workflow Language (CWL): a generic language for declaring how each step of a workflow is executed, what inputs it needs, what outputs it creates, and approximately what resources (RAM, storage, CPU threads, etc.) are required to run it; designed to write workflows that can be run on a variety of workflow engines
Dockstore: a registry of bioinformatics workflows (heavy emphasis on genomics) that includes a Docker container and a CWL specification for each workflow
toil: a production-grade workflow engine used primarily for bioinformatics workflows


Question:
I asked a relatively simple question. Unfortunately, the answers provoke far more questions! :-(
It seems that I don't actually understand RC circuits at all. In particular, why there's an R in there. It seems completely unnecessary. Surely the capacitor is doing all the work? What the heck do you need a resistor for?
Clearly my mental model of how this stuff works is incorrect somehow. So let me try to explain my mental model:
If you try to pass a direct current through a capacitor, you are just charging the two plates. Current will continue to flow until the capacitor is fully charged, at which point no further current can flow. At this point, the two ends of the wire might as well not even be connected.
Until, that is, you reverse the direction of the current. Now current can flow while the capacitor discharges, and continues to flow while the capacitor recharges in the opposite polarity. But after that, once again the capacitor becomes fully charged, and no further current can flow.
It seems to me that if you pass an alternating current through a capacitor, one of two things will happen. If the wave period is longer than the time to fully charge the capacitor, the capacitor will spend most of the time fully charged, and hence most of the current will be blocked. But if the wave period is shorter, the capacitor will never reach a fully-charged state, and most of the current will get through.
By this logic, a single capacitor on its own is a perfectly good high-pass filter.
So... why does everybody insist that you have to have a resistor as well to make a functioning filter? What am I missing?
Consider, for example, this circuit from Wikipedia:

What the hell is that resistor doing there? Surely all that does is short-circuit all the power, such that no current reaches the other side at all.
Next consider this:

This is a little strange. A capacitor in parallel? Well... I suppose if you believe that a capacitor blocks DC and passes AC, that would mean that at high frequencies, the capacitor shorts-out the circuit, preventing any power getting through, while at low frequencies the capacitor behaves as if it's not there. So this would be a low-pass filter. Still doesn't explain the random resistor through, uselessly blocking nearly all the power on that rail...
Obviously the people who actually design this stuff know something that I don't! Can anyone enlighten me? I tried the Wikipedia article on RC circuits, but it just talks about a bunch of Laplace transform stuff. It's neat that you can do that, I'm trying to understand the underlying physics. And failing!
(Similar arguments to the above suggest that an inductor by itself ought to make a good low-pass filter — but again, all the literature seems to disagree with me. I don't know whether that's worthy of a separate question or not.)

Let's try this Wittgenstein's ladder style.
First let's consider this:

simulate this circuit – Schematic created using CircuitLab
We can calculate the current through R1 with Ohm's law:
$$ {1\:\mathrm V \over 100\:\Omega} = 10\:\mathrm{mA} $$
We also know that the voltage across R1 is 1V. If we use ground as our reference, then how does 1V at the top of the resistor become 0V at the bottom of the resistor? If we could stick a probe somewhere in the middle of R1, we should measure a voltage somewhere between 1V and 0V, right?
A resistor with a probe we can move around on it...sounds like a potentiometer, right?

simulate this circuit
By adjusting the knob on the potentiometer, we can measure any voltage between 0V and 1V.
Now what if instead of a pot, we use two discrete resistors?

simulate this circuit
This is essentially the same thing, except we can't move the wiper on the potentiometer: it's stuck at a position 3/4th from the top. If we get 1V at the top, and 0V at the bottom, then 3/4ths of the way up we should expect to see 3/4ths of the voltage, or 0.75V.
What we have made is a resistive voltage divider. It's behavior is formally described by the equation:
$$ V_\text{out} = {R_2 \over R_1 + R_2} \cdot V_\text{in} $$
Now, what if we had a resistor with a resistance that changed with frequency? We could do some neat stuff. That's what capacitors are.
At a low frequency (the lowest frequency being DC), a capacitor looks like a large resistor (infinite at DC). At higher frequencies, the capacitor looks like a smaller resistor. At infinite frequency, a capacitor has to resistance at all: it looks like a wire.
So:

simulate this circuit
For high frequencies (top right), the capacitor looks like a small resistor. R3 is very much smaller than R2, so we will measure a very small voltage here. We could say that the input has been attenuated a lot.
For low frequencies (lower right), the capacitor looks like a large resistor. R5 is very much bigger than R4, so here we will measure a very large voltage, almost all of the input voltage, that is, the input voltage has been attenuated very little.
So high frequencies are attenuated, and low frequencies are not. Sounds like a low-pass filter.
And if we exchange the places of the capacitor and the resistor, the effect is reversed, and we have a high-pass filter.
However, capacitors aren't really resistors. What they are though, are impedances. The impedance of a capacitor is:
$$ Z_\text{capacitor} = -j{1 \over 2 \pi f C} $$
Where:

\$C\$ is the capacitance, in farads
\$f\$ is the frequency, in hertz
\$j\$ is the imaginary unit, \$\sqrt{-1}\$

Notice that, because \$f\$ is in the denominator, the impedance decreases as frequency increases.
Impedances are complex numbers, because they contain \$j\$. If you know how arithmetic operations work on complex numbers, then you can still use the voltage divider equation, except we will use \$Z\$ instead of \$R\$ to suggest we are using impedances instead of simple resistances:
$$ V_\text{out} = V_{in}{Z_2 \over Z_1 + Z_2}$$
And from this, you can calculate the behavior of any RC circuit, and a good deal more.


Question:
I know of, and have used f2py2e to wrap some old Fortran 77 code, but my understanding is that it does not work with newer Fortran 95 code. I've researched what I should use, and have come across fwrap and G3 f2py, neither of which seem to give any explanation of their current state, or how to use them (beyond basic usage).
I have also seen that the version of f2py has the option to use the third generation f2py, but it is commented as being non-functional. Given this, I don't know which project I should use for a uni project. Which one should I use for new code?
P.S. This is basically the same question as  it was suggested that asking here might give better answers.

You can use the Python builtin ctypes module as described on fortran90.org.  It is pretty straight forward and doesn't require any external dependencies.  Also, the ndpointer arg type helper is very handy.


Question:
A common question, here and elsewhere. Is C++ suitable for embedded systems?
Microcontrollers? RTOSes? Toasters? Embedded PCs?
Is OOP useful on microcontrollers?
Does C++ remove the programmer too far from the hardware to be efficient?
Should Arduino's C++ (with no dynamic memory management, templates, exceptions) be considered as "real C++"?
(Hopefully, this wiki will serve as a place to contain this potential holy war)

Yes, C++ is still useful in embedded systems.  As everyone else has said, it still depends on the system itself, like an 8-bit uC would probably be a no-no in my book even though there is a compiler out there and some people do it (shudder). There's still an advantage to using C++ even when you scale it down to something like "C+" even in a 8-bit micro world.  What do I mean by "C+"? I mean don't use new/delete, avoid exceptions, avoid virtual classes with inheritance, possibly avoid inheritance all together, be very careful with templates, use inline functions instead of macros, and use const variables instead of #defines.
I've been working both in C and C++ in embedded systems for well over a decade now, and some of my youthful enthusiasm for C++ has definitely worn off due to some real world problems that shake one's naivete.  I have seen the worst of C++ in an embedded systems which I would like to refer to as "CS programmers gone wild in an EE world."  In fact, that is something I'm working on with my client to improve this one codebase they have among others.
The danger of C++ is because it's a very very powerful tool much like a two-edged sword that can cut both your arm and leg off if not educated and disciplined properly in it's language and general programming itself.  C is more like a single-edged sword, but still just as sharp.  With C++ it's too easy to get very high-levels of abstraction and create obfuscated interfaces that become meaningless in the long-term, and that's partly due to C++ flexibility in solving the same problem with many different language features(templates, OOP, procedural, RTTI, OOP+templates, overloading, inlining).
I finished a two 4-hour seminars on Embedded Software in C++ by the C++ guru, Scott Meyers.  He pointed out some things about templates that I never considered before and how much more they can help creating safety-critical code.  The jist of it is, you can't have dead code in software that has to meet stringent safety-critical code requirements.  Templates can help you accomplish this, since the compiler only creates the code it needs when instantiating templates.  However, one must become more thoroughly educated in their use to design correctly for this feature which is harder to accomplish in C because linkers don't always optimize dead code. He also demonstrated a feature of templates that could only be accomplished in C++ and would have kept the Mars Climate Observer from crashing had NASA implemented a similar system to protect units of measurement in the calculations.
Scott Meyers is a very big proponent on templates and judicious use of inlining, and I must say I'm still skeptical on being gung ho about templates.  I tend to shy away from them, even though he says they should only be applied where they become the best tool. He also makes the point that C++ gives you the tools to make really good interfaces that are easy to use right and make it hard to use wrong. Again, that's the hard part.  One must come to a level of mastery in C++ before you can know how to apply these features in most efficient way to be the best design solution.
The same goes for OOP.  In the embedded world, you must familiarize yourself with what kind of code the compiler is going to spit out to know if you can handle the run-time costs of run-time polymorphism.  You need to be willing to make measurements as well to prove your design is going to meet your deadline requirements. Is that new InterruptManager class going to make my interrupt latency too long? There are other forms of polymorphism that may fit your problem better such as link-time polymorphism which C can do as well, but C++ can do through the Pimpl design pattern (Opaque pointer).
I say that all to say, that C++ has its place in the embedded world. You can hate it all you want, but it's not going away. It can be written in a very efficient manner, but it's harder to learn how to do it correctly than with C.  It can sometimes work better than C at solving a problem and sometimes expressing a better interface, but again, you've got to educate yourself and not be afraid to learn how.


Question:
Fun with Math time.
My mom gave me a roll of toilet paper to put it in the bathroom, and looking at it I immediately wondered about this: is it possible, through very simple math, to calculate (with small error) the total paper length of a toilet roll?
Writing down some math, I came to this study, which I share with you because there are some questions I have in mind, and because as someone rightly said: for every problem there always are at least 3 solutions.
I started by outlining the problem in a geometrical way, namely looking only at the essential: the roll from above, identifying the salient parameters:

Parameters
$r = $ radius of internal circle, namely the paper tube circle;
$R = $ radius of the whole paper roll;
$b = R - r = $ "partial" radius, namely the difference of two radii as stated.
First Point
I treated the whole problem in the discrete way. [See the end of this question for more details about what does it mean]
Calculation
In a discrete way, the problem asks for the total length of the rolled paper, so the easiest way is to treat the problem by thinking about the length as the sum of the whole circumferences starting by radius $r$ and ending with radius $R$.
But how many circumferences are there?
Here is one of the main points, and then I thought about introducing a new essential parameter, namely the thickness of a single sheet. Notice that it's important to have to do with measurable quantities.
Calling $h$ the thickness of a single sheet, and knowing $b$ we can give an estimate of how many sheets $N$ are rolled:
$$N = \frac{R - r}{h} = \frac{b}{h}$$
Having to compute a sum, the total length $L$ is then:
$$L = 2\pi r + 2\pi (r + h) + 2\pi (r + 2h) + \cdots + 2\pi R$$
or better:
$$L = 2\pi (r + 0h) + 2\pi (r + h) + 2\pi (r + 2h) + \cdots + 2\pi (r + Nh)$$
In which obviously $2\pi (r + 0h) = 2\pi r$ and $2\pi(r + Nh) = 2\pi R$.
Writing it as a sum (and calculating it) we get:
$$
\begin{align}
L = \sum_{k = 0}^N\ 2\pi(r + kh) & = 2\pi r + 2\pi R + \sum_{k = 1}^{N-1}\ 2\pi(r + kh)
\\\\
& = 2\pi r + 2\pi R + 2\pi \sum_{k = 1}^{N-1} r + 2\pi h \sum_{k = 1}^{N-1} k
\\\\
& = 2\pi r + 2\pi R + 2\pi r(N-1) + 2\pi h\left(\frac{1}{2}N(N-1)\right)
\\\\
& = 2\pi r N + 2\pi R + \pi hN^2 - \pi h N
\end{align}
$$
Using now: $N = \frac{b}{h}$; $R = b - a$ and $a = R - b$ (because $R$ is easily measurable), we arrive after little algebra to
$$\boxed{L = 4\pi b + 2\pi R\left(\frac{b}{h} - 1\right) - \pi b\left(1 + \frac{b}{h}\right)}$$
Small Example:
$h = 0.1$ mm; $R = 75$ mm; $b = 50$ mm thence $L = 157$ meters
which might fit.
Final Questions:
1) Could it be a good approximation?
2) What about the $\gamma$ factor? Namely the paper compression factor?
3) Could exist a similar calculation via integration over a spiral path? Because actually it's what it is: a spiral.
Thank you so much for the time spent for this maybe tedious maybe boring maybe funny question!

The assumption that the layers are all cylindrical is a good first approximation.
The assumption that the layers form a logarithmic
spiral is not a good assumption at all, because it supposes that the
thickness of the paper at any point is proportional to its distance
from the center. This seems to me to be quite absurd.
An alternative assumption is that the layers form an Archimedean spiral.
This is slightly more realistic, since it says the paper has a uniform
thickness from beginning to end. But this assumption is not a much more
realistic than the assumption that all layers are cylindrical;
in fact, in some ways it is less realistic.
Here's how a sheet of thickness $h$ actually wraps around a cylinder.
First, we glue one side of the sheet (near the end of the sheet)
to the surface of the cylinder. Then we start rotating the cylinder.
As the cylinder rotates, it pulls the outstretched sheet around itself.
Near the end of the first full rotation of the cylinder, the
wrapping looks like this:

Notice that the sheet lies directly on the surface of the cylinder,
that is, this part of the wrapped sheet is cylindrical.
At some angle of rotation, the glued end of the sheet hits the part of
the sheet that is being wrapped. The point where the sheet is tangent to
the cylinder at that time is the last point of contact with the cylinder;
the sheet goes straight from that point to the point of contact with
the glued end, and then proceeds to wrap in a cylindrical shape around
the first layer of the wrapped sheet, like this:

As we continue rotating the cylinder, it takes up more and more layers
of the sheet, each layer consisting of a cylindrical section going
most of the way around the roll, followed by a flat section that joins
this layer to the next layer. We end up with something like this:

Notice that I cut the sheet just at the point where it was about to
enter another straight section. I claim (without proof) that this
produces a local maximum in the ratio of the length of the wrapped sheet
of paper to the greatest thickness of paper around the inner cylinder.
The next local maximum (I claim) will occur at the corresponding
point of the next wrap of the sheet.
The question now is what the thickness of each layer is.
The inner surface of the cylindrical portion of each layer of the
wrapped sheet has less area than the outer surface, but the portion of
the original (unwrapped) sheet that was wound onto the roll to make this layer had equal area on both sides. So either the inner surface was
somehow compressed, or the outer surface was stretched, or both.
I think the most realistic assumption is that both compression and stretching
occurred. In reality, I would guess that the inner surface is compressed more than the outer surface is stretched, but I do not know what the
most likely ratio of compression to stretching would be.
It is simpler to assume that the two effects are equal.
The length of the sheet used to make any part of one layer of the roll
is therefore equal to the length of the surface midway between the
inner and outer surfaces of that layer.
For example, to wrap the first layer halfway around the central cylinder
of radius $r$, we use a length $\pi\left(r + \frac h2\right)$
of the sheet of paper.
The reason this particularly simplifies our calculations is that the
length of paper used in any part of the roll is simply the area of the
cross-section of that part of the roll divided by the thickness of the paper.
The entire roll has inner radius $r$ and outer radius $R = r + nh$,
where $n$ is the maximum number of layers at any point
around the central cylinder. (In the figure, $n = 5$.)
The blue lines are sides of a right triangle whose vertices are
the center of the inner cylinder and the points where the first layer last touches the inner cylinder and first touches its own end.
This triangle has hypotenuse $r + h$ and one leg is $r$, so the other
leg (which is the length of the straight portion of the sheet)
is $$ \sqrt{(r + h)^2 - r^2} = \sqrt{(2r + h)h}.$$
Each straight portion of each layer is connected to the next layer
of paper by wrapping around either the point of contact with the glued
end of the sheet (the first time) or around the shape made by
wrapping the previous layer around this part of the layer below;
this forms a segment of a cylinder between the red lines with center at
the point of contact with the glued end.
The angle between the red lines is the same as the angle of the blue
triangle at the center of the cylinder, namely
$$ \alpha = \arccos \frac{r}{r+h}.$$
Now let's add up all parts of the roll. We have an almost-complete
hollow cylinder with inner radius $r$ and outer radius $R$,
missing only a segment of angle $\alpha$. The cross-sectional area of this is
$$ A_1 = \left(\pi - \frac{\alpha}{2} \right) (R^2 - r^2).$$
We have a rectangular prism whose cross-sectional area is the product
of two of its sides,
$$ A_2 = (R - r - h) \sqrt{(2r + h)h}.$$
Finally, we have a segment of a cylinder of radius $R - r - h$
(between the red lines) whose cross-sectional area is
$$ A_3 = \frac{\alpha}{2} (R - r - h)^2.$$
Adding this up and dividing by $h$, the total length of the sheet
comes to
\begin{align}
 L &= \frac1h (A_1+A_2+A_3)\\
   &= \frac1h \left(\pi - \frac{\alpha}{2} \right) (R^2 - r^2)
     + \frac1h (R - r - h) \sqrt{(2r + h)h}
     + \frac{\alpha}{2h} (R - r - h)^2.
\end{align}
For $n$ layers on a roll, using the formula $R = r + nh$,
we have $R - r = nh$, $R + r = 2r + nh$,
$R^2 - r^2 = (R+r)(R-r) = (2r + nh)nh$,
and $R - r - h = (n - 1)h$.
The length then is
\begin{align}
 L &= \left(\pi - \frac{\alpha}{2} \right) (2r + nh)n
     + (n - 1) \sqrt{(2r + h)h}
     + \frac{\alpha h}{2} (n - 1)^2\\
  &= 2n\pi r + n^2\pi h
      + (n-1) \sqrt{(2r + h)h}
      - \left( n(r + h) - \frac h2 \right) \arccos \frac{r}{r+h}\\
  &= n (R + r) \pi
      + (n-1) \sqrt{(2r + h)h}
      - \left( n(r + h) - \frac h2 \right) \arccos \frac{r}{r+h}.
\end{align}
One notable difference between this estimate and some others
(including the original) is that I assume there can be at most
$(R-r)/h$ layers of paper over any part of the central cylinder,
not $1 + (R-r)/h$ layers.
The total length is the number of layers times $2\pi$ times the
average radius, $(R + r)/2$, adjusted by the amount that is missing in the
section of the roll that is only $n - 1$ sheets thick.

Things are not too much worse if we assume a different but uniform ratio
of inner-compression to outer-stretching, provided that we keep the
same paper thickness regardless of curvature; we just have to make an
adjustment to the inner and outer radii of any cylindrical segment of the roll, which I think I'll leave as "an exercise for the reader."
But this involves a change in volume of the sheet of paper.
If we also keep the volume constant, we find that the sheet gets thicker
or thinner depending on the ratio of stretch to compression and
the curvature of the sheet.
With constant volume, the length of paper in the main part of the
roll (everywhere where we get the the full number of layers) is the
same as in the estimate above, but the total length of the parts of the
sheet that connect one layer to the next might change slightly.

Update: Per request, here are the results of applying the formula
above to the input values given as an example in the question:
$h=0.1$, $R=75$, and $r=25$ (inferred from $R-r=b=50$), all measured
in millimeters.
Since $n = (R-r)/h$, we have $n = 500$.
For a first approximation of the total length of paper,
let's consider just the first term of the formula. This gives us
$$
L_1 = n (R + r) \pi = 500 \cdot 100 \pi \approx 157079.63267949,
$$
or about $157$ meters, the same as in the example in the question.
The remaining two terms yield
\begin{align}
L - L_1
&= (n-1)\sqrt{(2r + h)h}
      - \left( n(r + h) - \frac h2 \right) \arccos\frac{r}{r+h} \\
&= 499\sqrt{50.1 \cdot 0.1} - (500(25.1) - 0.05)\arccos\frac{25}{25.1} \\
&\approx -3.72246774.
\end{align}
This is a very small correction, less than $2.4\times 10^{-5} L_1$.
In reality (as opposed to my idealized model
of constant-thickness constant-volume toilet paper), this
"correction" is surely insignificant compared to the uncertainties of
estimating the average thickness of the paper in each layer of a roll
(not to mention any non-uniformity
in how it is rolled by the manufacturing machinery).
We can also compare $\lvert L - L_1 \rvert$ to the amount of paper that
would be missing if the paper in the "flat" segment of the roll were
instead $n - 1$ layers following the curve of the rest of the paper.
The angle $\alpha$ is about $0.089294$ radians (about $5.1162$ degrees),
so if the missing layer were the innermost layer, its length would be
$25.05 \alpha \approx 2.24$, and if it were the outermost layer
it would be $74.95 \alpha \approx 6.69$ (in millimeters).
Just for amusement, I also tried expanding $L - L_1$ as a power
series around $h = 0$ (with a little help from Wolfram Alpha).
(To make $L - L_1$ a function of one variable $h$ with constants $R$ and $r$,
make the substitution $n = (R - r)/h$.)
This turns out to be a series of powers of $\sqrt h$ whose leading term is
$$
-\frac{(R + 2r)\sqrt2}{3\sqrt r} \sqrt h.
$$
Plugging in the values from the example, this evaluates to
approximately $-3.7267799625$.
If you really wanted the length of the idealized toilet roll to the
nearest millimeter, but could tolerate an error of a few $\mu\mathrm m$
(for typical dimensions of a toilet roll),
a suitable approximation would be
$$
L \approx \frac{\pi (R^2 - r^2)}{h} - \frac{(R + 2r)\sqrt2}{3\sqrt r} \sqrt h.
$$


Question: Most of today's encryption, such as the RSA, relies on the integer factorization, which is not believed to be a NP-hard problem, but it belongs to BQP, which makes it vulnerable to quantum computers. I wonder, why has there not been an encryption algorithm which is based on an known NP-hard problem. It sounds (at least in theory) like it would make a better encryption algorithm than a one which is not proven to be NP-hard.

Worst-case Hardness of NP-complete problems is not sufficient for cryptography.  Even if NP-complete problems are hard in the worst-case ($P \ne NP$), they still could be efficiently solvable in the average-case. Cryptography assumes the existence of average-case intractable problems in NP. Also, proving the existence of hard-on-average problems in NP using the $P \ne NP$ assumption is a major open problem.
An excellent read is the classic by Russell Impagliazzo, A Personal View of Average-Case Complexity, 1995.
An excellent survey is Average-Case Complexity by Bogdanov and Trevisan, Foundations and Trends in Theoretical Computer Science Vol. 2, No 1 (2006) 1–106


Question:
I'd like to learn the differences between 3 common formats such as FASTA, FASTQ and SAM. How they are different? Are there any benefits of using one over another?
Based on Wikipedia pages, I can't tell the differences between them.

Let’s start with what they have in common: All three formats store

sequence data, and
sequence metadata.

Furthermore, all three formats are text-based.
However, beyond that all three formats are different and serve different purposes.
Let’s start with the simplest format:
FASTA
FASTA stores a variable number of sequence records, and for each record it stores the sequence itself, and a sequence ID. Each record starts with a header line whose first character is >, followed by the sequence ID. The next lines of a record contain the actual sequence.
The Wikipedia artice gives several examples for peptide sequences, but since FASTQ and SAM are used exclusively (?) for nucleotide sequences, here’s a nucleotide example:
>Mus_musculus_tRNA-Ala-AGC-1-1 (chr13.trna34-AlaAGC)
GGGGGTGTAGCTCAGTGGTAGAGCGCGTGCTTAGCATGCACGAGGcCCTGGGTTCGATCC
CCAGCACCTCCA
>Mus_musculus_tRNA-Ala-AGC-10-1 (chr13.trna457-AlaAGC)
GGGGGATTAGCTCAAATGGTAGAGCGCTCGCTTAGCATGCAAGAGGtAGTGGGATCGATG
CCCACATCCTCCA

The ID can be in any arbitrary format, although several conventions exist.
In the context of nucleotide sequences, FASTA is mostly used to store reference data; that is, data extracted from a curated database; the above is adapted from GtRNAdb (a database of tRNA sequences).
FASTQ
FASTQ was conceived to solve a specific problem arising during sequencing: Due to how different sequencing technologies work, the confidence in each base call (that is, the estimated probability of having correctly identified a given nucleotide) varies. This is expressed in the Phred quality score. FASTA had no standardised way of encoding this. By contrast, a FASTQ record contains a sequence of quality scores for each nucleotide.
A FASTQ record has the following format:

A line starting with @, containing the sequence ID.
One or more lines that contain the sequence.
A new line starting with the character +, and being either empty or repeating the sequence ID.
One or more lines that contain the quality scores.

Here’s an example of a FASTQ file with two records:
@071112_SLXA-EAS1_s_7:5:1:817:345
GGGTGATGGCCGCTGCCGATGGCGTC
AAATCCCACC
+
IIIIIIIIIIIIIIIIIIIIIIIIII
IIII9IG9IC
@071112_SLXA-EAS1_s_7:5:1:801:338
GTTCAGGGATACGACGTTTGTATTTTAAGAATCTGA
+
IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII6IBI

FASTQ files are mostly used to store short-read data from high-throughput sequencing experiments. The sequence and quality scores are usually put into a single line each, and indeed many tools assume that each record in a FASTQ file is exactly four lines long, even though this isn’t guaranteed.
As with FASTA, the format of the sequence ID isn’t standardised, but different producers of FASTQ use fixed notations that follow strict conventions.
SAM
SAM files are so complex that a complete description [PDF] takes 15 pages. So here’s the short version.
The original purpose of SAM files is to store mapping information for sequences from high-throughput sequencing. As a consequence, a SAM record needs to store more than just the sequence and its quality, it also needs to store information about where and how a sequence maps into the reference.
Unlike the previous formats, SAM is tab-based, and each record, consisting of either 11 or 12 fields, fills exactly one line. Here’s an example (tabs replaced by fixed-width spacing):
r001  99  chr1  7 30  17M         =  37  39  TTAGATAAAGGATACTG   IIIIIIIIIIIIIIIII
r002  0   chrX  9 30  3S6M1P1I4M  *  0   0   AAAAGATAAGGATA      IIIIIIIIII6IBI    NM:i:1

For a description of the individual fields, refer to the documentation. The relevant bit is this: SAM can express exactly the same information as FASTQ, plus, as mentioned, the mapping information. However, SAM is also used to store read data without mapping information.
In addition to sequence records, SAM files can also contain a header, which stores information about the reference that the sequences were mapped to, and the tool used to create the SAM file. Header information precede the sequence records, and consist of lines starting with @.
SAM itself is almost never used as a storage format; instead, files are stored in BAM format, which is a compact, gzipped, binary representation of SAM. It stores the same information, just more efficiently. And, in conjunction with a search index, allows fast retrieval of individual records from the middle of the file (= fast random access). BAM files are also much more compact than compressed FASTQ or FASTA files.

The above implies a hierarchy in what the formats can store: FASTA ⊂ FASTQ ⊂ SAM.
In a typical high-throughput analysis workflow, you will encounter all three file types:

FASTA to store the reference genome/transcriptome that the sequence fragments will be mapped to.
FASTQ to store the sequence fragments before mapping.
SAM/BAM to store the sequence fragments after mapping.


Question:
As someone who holds a BA in physics I was somewhat scandalized when I began working with molecular simulations. It was a bit of a shock to discover that even the most detailed and computationally expensive simulations can't quantitatively reproduce the full behavior of water from first principles.
Previously, I had been under the impression that the basic laws of quantum mechanics were a solved problem (aside from gravity, which is usually assumed to be irrelevant at molecular scale). However, it seems that once you try to scale those laws up and apply them to anything larger or more complex than a hydrogen atom their predictive power begins to break down.
From a mathematics point of view, I understand that the wave functions quickly grow too complicated to solve and that approximations (such as Born-Oppenheimer) are required to make the wave functions more tractable. I also understand that those approximations introduce errors which propagate further and further as the time and spatial scales of the system under study increase.
What is the nature of the largest and most significant of these approximation errors? How can I gain an intuitive understanding of those errors? Most importantly, how can we move towards an ab-initio method that will allow us to accurately simulate whole molecules and populations of molecules? What are the biggest unsolved problems that are stopping people from developing these kinds of simulations?

As far as I'm aware, the most accurate methods for static calculations are Full Configuration Interaction with a fully relativistic four-component Dirac Hamiltonian and a "complete enough" basis set. I'm not an expert in this particular area, but from what I know of the method, solving it using a variational method (rather than a Monte-Carlo based method) scales shockingly badly, since I think the number of Slater determinants you have to include in your matrix scales something like $O(^{n_{orbs}}C_{n_e})$. (There's an article on the computational cost here.) The related Monte-Carlo methods and methods based off them using "walkers" and networks of determinants can give results more quickly, but as implied above, aren't variational. And are still hideously costly.
Approximations currently in practical use just for energies for more than two atoms include:

Born Oppenheimer, as you say: this is almost never a problem unless your system involves hydrogen atoms tunneling, or unless you're very near a state crossing/avoided crossing. (See, for example, conical intersections.) Conceptually, there are non-adiabatic methods for the wavefunction/density, including CPMD, and there's also Path-Integral MD which can account for nuclear tunneling effects.
Nonrelativistic calculations, and two-component approximations to the Dirac equation: you can get an exact two-component formulation of the Dirac equation, but more practically the Zeroth-Order Regular Approximation (see Lenthe et al, JChemPhys, 1993) or the Douglas-Kroll-Hess Hamiltonian (see Reiher, ComputMolSci, 2012) are commonly used, and often (probably usually) neglecting spin-orbit coupling.
Basis sets and LCAO: basis sets aren't perfect, but you can always make them more complete.
DFT functionals, which tend to attempt to provide a good enough attempt at the exchange and correlation without the computational cost of the more advanced methods below. (And which come in a few different levels of approximation. LDA is the entry-level one, GGA, metaGGA and including exact exchange go further than that, and including the RPA is still a pretty expensive and new-ish technique as far as I'm aware. There are also functionals which use differing techniques as a function of separation, and some which use vorticity which I think have application in magnetic or aromaticity studies.) (B3LYP, the functional some people love and some people love to hate, is a GGA including a percentage of exact exchange.)
Configuration Interaction truncations: CIS, CISD, CISDT, CISD(T), CASSCF, RASSCF, etc. These are all approximations to CI which assume the most important excited determinants are the least excited ones.
Multi-reference Configuration Interaction (truncations): Ditto, but with a few different starting reference states.
Coupled-Cluster method: I don't pretend to properly understand how this works, but it obtains similar results to Configuration Interaction truncations with the benefit of size-consistency (i.e. $E(H_2) \times 2 = E((H_2)_2$ (at large separation)).

For dynamics, many of the approximations refer to things like the limited size of a tractable system, and practical timestep choice -- it's pretty standard stuff in the numerical time simulation field. There's also temperature maintenance (see Nose-Hoover or Langevin thermostats). This is mostly a set of statistical mechanics problems, though, as I understand it.
Anyway, if you're physics-minded, you can get a pretty good feel for what's neglected by looking at the formulations and papers about these methods: most commonly used methods will have at least one or two papers that aren't the original specification explaining their formulation and what it includes. Or you can just talk to people who use them. (People who study periodic systems with DFT are always muttering about what different functionals do and don't include and account for.) Very few of the methods have specific surprising omissions or failure modes. The most difficult problem appears to be proper treatment of electron correlation, and anything above the Hartree-Fock method, which doesn't account for it at all, is an attempt to include it.
As I understand it, getting to the accuracy of Full relativistic CI with complete basis sets is never going to be cheap without dramatically reinventing (or throwing away) the algorithms we currently use. (And for people saying that DFT is the solution to everything, I'm waiting for your pure density orbital-free formulations.)
There's also the issue that the more accurate you make your simulation by including more contributions and more complex formulations, the harder it is to actually do anything with. For example, spin orbit coupling is sometimes avoided solely because it makes everything more complicated to analyse (but sometimes also because it has negligable effect), and the canonical Hartree-Fock or Kohn-Sham orbitals can be pretty useful for understanding qualitative features of a system without layering on the additional output of more advanced methods.
(I hope some of this makes sense, it's probably a bit spotty. And I've probably missed someone's favourite approximation or niggle.)


Question:
Suppose I would like to insert data-cables of varying diameters -- e.g., a cable of 5 mm diameter -- into the 6 mm diameter hole of a plastic enclosure. The wires within the cable are terminated via soldering to a PCB inside the enclosure.
What methods are used in the industry to ensure that pulling the cable won't make it slide in and out of the enclosure (thus preventing damage to the wire connections to the PCB inside)?

Some options that I have considered:

Two small lengths of thick heat shrink tubing placed around the cable, both just inside and just outside the wall of the enclosure. If the tubing is wide enough, then it will block the cable from sliding. This could work but may have to use too many layers of tubing and also the fit just by friction alone may not be strong enough.
Apply a thick layer of rubber-compatible adhesive in a circle around the cable, both just inside and just outside the wall of the enclosure. The glue blob would act as sort of a bolt/washer. This is too messy in practice, and probably not usable professionally.
Use rubber-and-steel-compatible adhesive to place two bolts around the cable, one just inside and one just outside the wall of the enclosure. The problem with this is that it is hard to find an adhesive that bonds well to both rubber and steel.

There are a few industry approaches to this.
The first is molded cables. The cables themselves have strain reliefs molded to fit a given entry point, either by  custom moulding or with off the shelf reliefs that are chemically welded/bonded to the cable. Not just glued, but welded together.

The second is entry points designed to hold the cable. The cable is bent in a z or u shape around posts to hold it in place. The strength of the cable is used to prevent it from being pulled out.

Similarly, but less often seen now in the days of cheap molding or diy kits, is this. The cable is screwed into a holder which is prevented from moving in OR out by the case and screw posts.

Both of those options are a bit out of an individual's reach.
The third is through the use of Cord Grips or Cable Glands, also known as grommets. Especially is a water tight fit is needed.

They are screwed on, the cable past through, then the grip part is screwed. These prevent the cable from moving in or out, as well as sealing the hole. Most can accommodate cables at least 80% of the size of the opening. Any smaller and they basically won't do the job.
Other options include cable fasteners or holders. These go around the cable and are screwed or bolted down (or use plastic press fits). These can be screwed into a pcb for example.

Cable grommets are a fairly hacky way of doing it, as they are not designed to hold onto the cable. Instead they are designed to prevent the cable from being cut or damaged on a sharp or thin edge. But they can do in a pinch. As can tying a knot, though that mainly prevents pull outs, but might not be ideal for digital signals. Pushing a cable in doesn't happen too often, so you might not worry about that.
Similar to the second method, is using two or three holes in a pcb to push a cable through (up, down, up), then pulling it tight. This moves the point of pressure away from the solder point and onto the cable+jacket.

The other industry method is avoiding all this in the first place, by using panel mounted connectors (or board mounted connectors like Dell does for power plugs, yuck).


Question:
I have many alignments from Rfam Database, and I would like to edit them.
I saw that many tools are used for Protein sequence alignments, but there is something specific to edit RNA alignments ?
e.g. Stockholm Alignment of Pistol (just few entries).
FP929053.1/1669026-1668956   AGUGGUCACAGCCACUAUAAACA-GGGCUU-UAAGCUGUG-AGCGUUGACCGUC----------ACAA-----CGGCGGUCAGGUAGUC
AFOX01000025.1/1981-1912     ACUCGUCUGAGCGAGUAUAAACA-GGUCAU-UAAGCUCAG-AGCGUUCACCGGG----------AUCA------UUCGGUGAGGUUGGC
HE577054.1/3246821-3246752   ACUCGUCUGAGCGAGUAUAAACA-GGUCAU-UAAGCUCAG-AGCGUUCACCGGG----------AUCA------UGCGGUGAGGUUGGC
CP000154.1/3364237-3364168   GUUCGUCUGAGCGAACGCAAACA-GGCCAU-UAAGCUCAG-AGCGUUCACUGGA----------UUCG------UCCAGUGAGAUUGGC`
`#=GC SS_cons                 <<<<__AAAAA_>>>>-------..<<<<-.----aaaaa.----<<<<<<<<<..........____....._>>>>>>>>>-->>>>`
`#=GC RF                      acUCGUCuggGCGAguAUAAAuA..cgCaU.UAgGCccaG.AGCGUcccggcgg..........uUau.....uccgccgggGGUuGcg
//

I would suggest use RALEE—RNALignment Editor in Emacs. It can get for you the consensus secondary structure, you can move left/right sequences and their secondary structures (you can't do it in JalView!), and more.
It's an Emacs mode, so could be a bit hard to start off, but just try, you don't have to use all Emacs features to edit your alignments!

The RALEE (RNA ALignment Editor in Emacs) tool provides a simple
  environment for RNA multiple sequence alignment editing, including
  structure-specific colour schemes, utilizing helper applications for
  structure prediction and many more conventional editing functions.

Sam Griffiths-Jones Bioinformatics (2005) 21 (2): 257-259.

Fig. You can move left/right sequences and their secondary structures (you can't do it in JalView!)


Question: Many seem to believe that $P\ne NP$, but many also believe it to be very unlikely that this will ever be proven. Is there not some inconsistency to this? If you hold that such a proof is unlikely, then you should also believe that sound arguments for $P\ne NP$ are lacking. Or are there good arguments for $P\ne NP$ being unlikely, in a similar vein to say, the Riemann hypothesis holding for large numbers, or the very high lower bounds on the number of existing primes with a small distance apart viz. the Twin Prime conjecture?

People are skeptical because:

No proof has come from an expert without having been rescinded shortly thereafter
So much effort has been put into finding a proof, with no success, that it's assumed one will be either substantially complicated, or invent new mathematics for the proof
The "proofs" that arise frequently fail to address hurdles which are known to exist. For example, many claim that 3SAT is not in P, while providing an argument that also applies to 2SAT.

To be clear, the skepticism is of the proofs, not of the result itself.


Question:
I've always thought vaguely that the answer to the above question was affirmative along the following lines. Gödel's incompleteness theorem and the undecidability of the halting problem both being negative results about decidability and established by diagonal arguments (and in the 1930's), so they must somehow be two ways to view the same matters. And I thought that Turing used a universal Turing machine to show that the halting problem is unsolvable. (See also this math.SE question.)
But now that (teaching a course in computability) I look closer into these matters, I am rather bewildered by what I find. So I would like some help with straightening out my thoughts. I realise that on one hand Gödel's diagonal argument is very subtle: it needs a lot of work to construct an arithmetic statement that can be interpreted as saying something about it's own derivability. On the other hand the proof of the undecidability of the halting problem I found here is extremely simple, and doesn't even explicitly mention Turing machines, let alone the existence of universal Turing machines.
A practical question about universal Turing machines is whether it is of any importance that the alphabet of a universal Turing machine be the same as that of the Turing machines that it simulates. I thought that would be necessary in order to concoct a proper diagonal argument (having the machine simulate itself), but I haven't found any attention to this question in the bewildering collection of descriptions of universal machines that I found on the net. If not for the halting problem, are universal Turing machines useful in any diagonal argument?
Finally I am confused by this further section of the same WP article, which says that a weaker form of Gödel's incompleteness follows from the halting problem: "a complete, consistent and sound axiomatisation of all statements about natural numbers is unachievable" where "sound" is supposed to be the weakening. I know a theory is consistent if one cannot derive a contradiction, and a complete theory about natural numbers would seem to mean that all true statements about natural numbers can be derived in it; I know Gödel says such a theory does not exist, but I fail to see how such a hypothetical beast could possibly fail to be sound, i.e., also derive statements which are false for the natural numbers: the negation of such a statement would be true, and therefore by completeness also derivable, which would contradict consistency.
I would appreciate any clarification on one of these points.

I recommend you to check Scott Aaronson's blog post on a proof of the Incompleteness Theorem via Turing machines and Rosser's Theorem. His proof of the incompleteness theorem is extremely simple and easy to follow.


Question: Is there a standard and accepted method for selecting the number of layers, and the number of nodes in each layer, in a feed-forward neural network? I'm interested in automated ways of building neural networks.

I realize this question has been answered, but I don't think the extant answer really engages the question beyond pointing to a link generally related to the question's subject matter. In particular, the link describes one technique for programmatic network configuration, but that is not a "[a] standard and accepted method" for network configuration.
By following a small set of clear rules, one can programmatically set a competent network architecture (i.e., the number and type of neuronal layers and the number of neurons comprising each layer). Following this schema will give you a competent architecture but probably not an optimal one.
But once this network is initialized, you can iteratively tune the configuration during training using a number of ancillary algorithms; one family of these works by pruning nodes based on (small) values of the weight vector after a certain number of training epochs--in other words, eliminating unnecessary/redundant nodes (more on this below).
So every NN has three types of layers: input, hidden, and output.
Creating the NN architecture, therefore, means coming up with values for the number of layers of each type and the number of nodes in each of these layers.
The Input Layer
Simple--every NN has exactly one of them--no exceptions that I'm aware of.
With respect to the number of neurons comprising this layer, this parameter is completely and uniquely determined once you know the shape of your training data. Specifically, the number of neurons comprising that layer is equal to the number of features (columns) in your data. Some NN configurations add one additional node for a bias term.
The Output Layer
Like the Input layer, every NN has exactly one output layer. Determining its size (number of neurons) is simple; it is completely determined by the chosen model configuration.
Is your NN going to run in Machine Mode or Regression Mode (the ML convention of using a term that is also used in statistics but assigning a different meaning to it is very confusing)? Machine mode: returns a class label (e.g., "Premium Account"/"Basic Account"). Regression Mode returns a value (e.g., price).
If the NN is a regressor, then the output layer has a single node.
If the NN is a classifier, then it also has a single node unless softmax is used
in which case the output layer has one node per class label in your model.
The Hidden Layers
So those few rules set the number of layers and size (neurons/layer) for both the input and output layers. That leaves the hidden layers.
How many hidden layers? Well, if your data is linearly separable (which you often know by the time you begin coding a NN), then you don't need any hidden layers at all. Of course, you don't need an NN to resolve your data either, but it will still do the job.
Beyond that, as you probably know, there's a mountain of commentary on the question of hidden layer configuration in NNs (see the insanely thorough and insightful NN FAQ for an excellent summary of that commentary). One issue within this subject on which there is a consensus is the performance difference from adding additional hidden layers: the situations in which performance improves with a second (or third, etc.) hidden layer are very few. One hidden layer is sufficient for the large majority of problems.
So what about the size of the hidden layer(s)--how many neurons? There are some empirically derived rules of thumb; of these, the most commonly relied on is 'the optimal size of the hidden layer is usually between the size of the input and size of the output layers'. Jeff Heaton, the author of Introduction to Neural Networks in Java, offers a few more.
In sum, for most problems, one could probably get decent performance (even without a second optimization step) by setting the hidden layer configuration using just two rules: (i) the number of hidden layers equals one; and (ii) the number of neurons in that layer is the mean of the neurons in the input and output layers.
Optimization of the Network Configuration
Pruning describes a set of techniques to trim network size (by nodes, not layers) to improve computational performance and sometimes resolution performance. The gist of these techniques is removing nodes from the network during training by identifying those nodes which, if removed from the network, would not noticeably affect network performance (i.e., resolution of the data). (Even without using a formal pruning technique, you can get a rough idea of which nodes are not important by looking at your weight matrix after training; look at weights very close to zero--it's the nodes on either end of those weights that are often removed during pruning.) Obviously, if you use a pruning algorithm during training, then begin with a network configuration that is more likely to have excess (i.e., 'prunable') nodes--in other words, when deciding on network architecture, err on the side of more neurons, if you add a pruning step.
Put another way, by applying a pruning algorithm to your network during training, you can approach optimal network configuration; whether you can do that in a single "up-front" (such as a genetic-algorithm-based algorithm), I don't know, though I do know that for now, this two-step optimization is more common.


Question: I heard that the current limit for a USB port is 100mA. However, I also heard that some devices can get up to 1.8A from a port. How do you get past the 100mA limit?

I think I can attempt to clear this up.
USB-100mA
USB by default will deliver 100mA of current (it is 500mW power because we know it is 5v, right?) to a device. This is the most you can pull from a USB hub that does not have its own power supply, as they never offer more than 4 ports and keep a greedy 100mA for themselves.
Some computers that are cheaply built will use an bus-powered hub(all of your USB connections share the same 500mA source and the electronics acting as a hub use that source also) internally to increase the number of USB ports and to save a small amount of money. This can be frustrating, but you can always be guaranteed 100mA.
USB-500mA
When a device is connected it goes through enumeration. This is not a trivial process and can be seen in detail on Jan Axelson's site. As you can see this is a long process, but a chip from a company like FTDI will handle the hard part for you. They discuss enumeration in one of their app notes.
Near the end of enumeration you setup device parameters. Very specifically the configuration descriptors. If you look on this website they will show you all of the different pieces that can be set. It shows that you can get right up to 500mA of power requested. This is what you can expect from a computer. You can get FTDI chips to handle this for you, which is nice, as you only have to treat the chip as a serial line.
USB-1.8A
This is where things get interesting. You can purchase a charger that does outlet to USB at the store. This is a USB charging port. your computer does not supply these, and your device must be able to recognize it.
First, to get the best information about USB, you sometimes have to bite the bullet and go to the people whom write the spec. I found great information about the USB charging spec here. The link on the page that is useful is the link for battery charging. This link seems to be tied to revision number, so I have linked both in case the revision is updated people can still access the information.
Now, what does this mean. if you open up the batt_charging PDF and jump to chapter three they go into charging ports. Specifically 3.2.1 explains how this is gone about. Now they keep it very technical, but the key point is simple. A USB charging port places a termination resistance between D+ and D-. I would like to copy out the chapter that explains it, but it is a secured PDF and I cannot copy it out without retyping it.
Summing it up
You may pull 100mA from a computer port. You may pull 500mA after enumeration and setting the correct configuration. Computers vary their enforcement, as many others have said, but most I have had experience with will try to stop you. If you violate this, you may also damage a poorly design computer (Davr is spot on there, this is poor practice). You may pull up to 1.8A from a charging port, but this is a rare case where the port tells you something. You have to check for this and when it is verified you may do it. This is the same as buying a wall adapter, but you get to use a USB cable and USB port.
Why use the charging spec? So that when my phone dies, my charger charges it quickly, but if I do not have my charger I may pull power from a computer, while using the same hardware port to communicate files and information with my computer.
Please let me know if there is anything I can add.


Question:
This question: Can you get enough water by eating only fish? asks if a person could survive on fish alone. Can a person survive on fish and/ or blood alone of any species if stuck at sea or animal blood as a last resort where there is no water or fire?
Obviously if it was a fresh water fish there is water, but there are fresh water mud skippers that can breathe air and the water to tainted to drink in that case a fresh water fish blood maybe safer than the water.
Desalination would be the best way to process the blood but this is in emergency situation scenario.
From @PTwr Comment's Link: If you drink blood regularly, over a long period of time the buildup of iron in your system can cause iron overload. This syndrome, which sometimes affects people who have repeated blood transfusions, is one of the few conditions for which the correct treatment is bloodletting.

Blood is not a good source of water.
1 liter of blood contains about 800 mL of water, 170 grams of protein and 2 grams of sodium (calculated from the composition of lamb blood).
When metabolized, 170 grams of protein yields the amount of urea that requires 1,360 mL of water to be excreted in urine (calculated from here); 2 grams of sodium requires about 140 mL of water to be excreted (from here).
This means that drinking 1 liter of blood, which contains 800 mL of water, will result in 1,500 mL of water loss through the kidneys, which will leave you with 700 mL of negative water balance.
Fish blood can contain less protein, for example, trout (check Table 1) contains about 120 g of protein (plasma protein + hemoglobin) per liter of blood. Using the same calculation as above (1 g protein results in the excretion of 8 mL of urine), drinking of 1 liter of trout blood, which contains about 880 mL of water, will result in 960 mL of urine, so in 80 mL of negative water balance.
Turtle blood can contain about 80 g of protein (plasma protein + hemoglobin) and 3.4 g of sodium per liter. Drinking 1 liter of turtle blood, which contains about 920 mL of water, will result in 80 x 8 mL = 640 mL loss of urine due to protein, and ~240 mL due to sodium, which is 880 mL of urine in total. This leaves you with 40 mL of positive water balance (to get 2 liters of water per day you would need to drink 50 liters of turtle blood, which isn't realistic.
In various stories (The Atlantic, The Diplomat, The Telegraph), according to which people have survived by drinking turtle blood, they have also drunk rainwater, so we can't conclude it was turtle blood that helped them. I'm not aware of any story that would provide a convincing evidence that the blood of turtle or any other animal is hydrating.


Question:
Firstly, I am new to DSP and have no real education in it, but I am developing an audio visualization program and I am representing an FFT array as vertical bars as in a typical frequency spectrum visualization.
The problem I had was that the audio signal values changed too rapidly to produce a pleasing visual output if I just mapped the FFT values directly:

So I apply a simple function to the values in order to "smooth out" the result:
// pseudo-code
delta = fftValue - smoothedFftValue;
smoothedFftValue += delta * 0.2;
// 0.2 is arbitrary - the lower the number, the more "smoothing"

In other words, I am taking the current value and comparing it to the last, and then adding a fraction of that delta to the last value. The result looks like this:

So my question is:

Is this a well-established pattern or function for which a term already exsits? Is so, what is the term? I use "smoothing" above but I am aware that this means something very specific in DSP and may not be correct. Other than that it seemed maybe related to a volume envelope, but also not quite the same thing.
Are there better approaches or further study on solutions to this which I should look at?

Thanks for your time and apologies if this is a stupid question (reading other discussions here, I am aware that my knowledge is much lower than the average it seems).

What you've implemented is a single-pole lowpass filter, sometimes called a leaky integrator. Your signal has the difference equation:
$$
y[n] = 0.8 y[n-1] + 0.2 x[n]
$$
where $x[n]$ is the input (the unsmoothed bin value) and $y[n]$ is the smoothed bin value. This is a common way of implementing a simple, low-complexity lowpass filter. I've written about them several times before in previous answers; see [1] [2] [3].


Question: Can anyone state the difference between frequency response and impulse response in simple English?

The impulse response and frequency response are two attributes that are useful for characterizing linear time-invariant (LTI) systems. They provide two different ways of calculating what an LTI system's output will be for a given input signal. A continuous-time LTI system is usually illustrated like this:

In general, the system $H$ maps its input signal $x(t)$ to a corresponding output signal $y(t)$. There are many types of LTI systems that can have apply very different transformations to the signals that pass through them. But, they all share two key characteristics:

The system is linear, so it obeys the principle of superposition. Stated simply, if you linearly combine two signals and input them to the system, the output is the same linear combination of what the outputs would have been had the signals been passed through individually. That is, if $x_1(t)$ maps to an output of $y_1(t)$ and $x_2(t)$ maps to an output of $y_2(t)$, then for all values of $a_1$ and $a_2$,

$$
H\{a_1 x_1(t) + a_2 x_2(t)\} = a_1 y_1(t) + a_2 y_2(t)
$$

The system is time-invariant, so its characteristics do not change with time. If you add a delay to the input signal, then you simply add the same delay to the output. For an input signal $x(t)$ that maps to an output signal $y(t)$, then for all values of $\tau$,

$$
H\{x(t - \tau)\} = y(t - \tau)
$$
Discrete-time LTI systems have the same properties; the notation is different because of the discrete-versus-continuous difference, but they are a lot alike. These characteristics allow the operation of the system to be straightforwardly characterized using its impulse and frequency responses. They provide two perspectives on the system that can be used in different contexts.
Impulse Response:
The impulse that is referred to in the term impulse response is generally a short-duration time-domain signal. For continuous-time systems, this is the Dirac delta function $\delta(t)$, while for discrete-time systems, the Kronecker delta function $\delta[n]$ is typically used. A system's impulse response (often annotated as $h(t)$ for continuous-time systems or $h[n]$ for discrete-time systems) is defined as the output signal that results when an impulse is applied to the system input.
Why is this useful? It allows us to predict what the system's output will look like in the time domain. Remember the linearity and time-invariance properties mentioned above? If we can decompose the system's input signal into a sum of a bunch of components, then the output is equal to the sum of the system outputs for each of those components. What if we could decompose our input signal into a sum of scaled and time-shifted impulses? Then, the output would be equal to the sum of copies of the impulse response, scaled and time-shifted in the same way.
For discrete-time systems, this is possible, because you can write any signal $x[n]$ as a sum of scaled and time-shifted Kronecker delta functions:
$$
x[n] = \sum_{k=0}^{\infty} x[k] \delta[n - k]
$$
Each term in the sum is an impulse scaled by the value of $x[n]$ at that time instant. What would we get if we passed $x[n]$ through an LTI system to yield $y[n]$? Simple: each scaled and time-delayed impulse that we put in yields a scaled and time-delayed copy of the impulse response at the output. That is:
$$
y[n] = \sum_{k=0}^{\infty} x[k] h[n-k]
$$
where $h[n]$ is the system's impulse response. The above equation is the convolution theorem for discrete-time LTI systems. That is, for any signal $x[n]$ that is input to an LTI system, the system's output $y[n]$ is equal to the discrete convolution of the input signal and the system's impulse response.
For continuous-time systems, the above straightforward decomposition isn't possible in a strict mathematical sense (the Dirac delta has zero width and infinite height), but at an engineering level, it's an approximate, intuitive way of looking at the problem. A similar convolution theorem holds for these systems:
$$
y(t) = \int_{-\infty}^{\infty} x(\tau) h(t - \tau) d\tau
$$
where, again, $h(t)$ is the system's impulse response. There are a number of ways of deriving this relationship (I think you could make a similar argument as above by claiming that Dirac delta functions at all time shifts make up an orthogonal basis for the $L^2$ Hilbert space, noting that you can use the delta function's sifting property to project any function in $L^2$ onto that basis, therefore allowing you to express system outputs in terms of the outputs associated with the basis (i.e. time-shifted impulse responses), but I'm not a licensed mathematician, so I'll leave that aside). One method that relies only upon the aforementioned LTI system properties is shown here.
In summary: For both discrete- and continuous-time systems, the impulse response is useful because it allows us to calculate the output of these systems for any input signal; the output is simply the input signal convolved with the impulse response function.
Frequency response:
An LTI system's frequency response provides a similar function: it allows you to calculate the effect that a system will have on an input signal, except those effects are illustrated in the frequency domain. Recall the definition of the Fourier transform:
$$
X(f) = \int_{-\infty}^{\infty} x(t) e^{-j 2 \pi ft} dt
$$
More importantly for the sake of this illustration, look at its inverse:
$$
x(t) = \int_{-\infty}^{\infty} X(f) e^{j 2 \pi ft} df
$$
In essence, this relation tells us that any time-domain signal $x(t)$ can be broken up into a linear combination of many complex exponential functions at varying frequencies (there is an analogous relationship for discrete-time signals called the discrete-time Fourier transform; I only treat the continuous-time case below for simplicity). For a time-domain signal $x(t)$, the Fourier transform yields a corresponding function $X(f)$ that specifies, for each frequency $f$, the scaling factor to apply to the complex exponential at frequency $f$ in the aforementioned linear combination. These scaling factors are, in general, complex numbers. One way of looking at complex numbers is in amplitude/phase format, that is:
$$
X(f) = A(f) e^{j \phi(f)}
$$
Looking at it this way, then, $x(t)$ can be written as a linear combination of many complex exponential functions, each scaled in amplitude by the function $A(f)$ and shifted in phase by the function $\phi(f)$. This lines up well with the LTI system properties that we discussed previously; if we can decompose our input signal $x(t)$ into a linear combination of a bunch of complex exponential functions, then we can write the output of the system as the same linear combination of the system response to those complex exponential functions.
Here's where it gets better: exponential functions are the eigenfunctions of linear time-invariant systems. The idea is, similar to eigenvectors in linear algebra, if you put an exponential function into an LTI system, you get the same exponential function out, scaled by a (generally complex) value. This has the effect of changing the amplitude and phase of the exponential function that you put in.
This is immensely useful when combined with the Fourier-transform-based decomposition discussed above. As we said before, we can write any signal $x(t)$ as a linear combination of many complex exponential functions at varying frequencies. If we pass $x(t)$ into an LTI system, then (because those exponentials are eigenfunctions of the system), the output contains complex exponentials at the same frequencies, only scaled in amplitude and shifted in phase. These effects on the exponentials' amplitudes and phases, as a function of frequency, is the system's frequency response. That is, for an input signal with Fourier transform $X(f)$ passed into system $H$ to yield an output with a Fourier transform $Y(f)$,
$$
Y(f) = H(f) X(f) = A(f) e^{j \phi(f)} X(f)
$$
In summary: So, if we know a system's frequency response $H(f)$ and the Fourier transform of the signal that we put into it $X(f)$, then it is straightforward to calculate the Fourier transform of the system's output; it is merely the product of the frequency response and the input signal's transform. For each complex exponential frequency that is present in the spectrum $X(f)$, the system has the effect of scaling that exponential in amplitude by $A(f)$ and shifting the exponential in phase by $\phi(f)$ radians.
Bringing them together:
An LTI system's impulse response and frequency response are intimately related. The frequency response is simply the Fourier transform of the system's impulse response (to see why this relation holds, see the answers to this other question). So, for a continuous-time system:
$$
H(f) = \int_{-\infty}^{\infty} h(t) e^{-j 2 \pi ft} dt
$$
So, given either a system's impulse response or its frequency response, you can calculate the other. Either one is sufficient to fully characterize the behavior of the system; the impulse response is useful when operating in the time domain and the frequency response is useful when analyzing behavior in the frequency domain.


Question:
If $n>1$ is an integer, then $\sum \limits_{k=1}^n \frac1k$ is not an integer.
If you know Bertrand's Postulate, then you know there must be a prime $p$ between $n/2$ and $n$, so $\frac 1p$ appears in the sum, but $\frac{1}{2p}$ does not. Aside from $\frac 1p$, every other term $\frac 1k$ has $k$ divisible only by primes smaller than $p$. We can combine all those terms to get $\sum_{k=1}^n\frac 1k = \frac 1p + \frac ab$, where $b$ is not divisible by $p$. If this were an integer, then (multiplying by $b$) $\frac bp +a$ would also be an integer, which it isn't since $b$ isn't divisible by $p$.
Does anybody know an elementary proof of this which doesn't rely on Bertrand's Postulate? For a while, I was convinced I'd seen one, but now I'm starting to suspect whatever argument I saw was wrong.

Hint $ $ There is a $\rm\color{darkorange}{unique}$ denominator $\rm\,\color{#0a0} {2^K}$ having maximal power of $\:\!2,\,$ so scaling by $\rm\,\color{#c00}{2^{K-1}}$ we deduce a contradiction $\large \rm\, \frac{1}2 = \frac{c}d \,$ with odd $\rm\,d \:$ (vs. $\,\rm d = 2c),\,$ e.g.
$$\begin{eqnarray} & &\rm\ \ \ \  \color{0a0}{m}  &=&\ \  1 &+& \frac{1}{2} &+& \frac{1}{3} &+&\, \color{#0a0}{\frac{1}{4}} &+& \frac{1}{5} &+& \frac{1}{6} &+& \frac{1}{7} \\
&\Rightarrow\ &\rm\ \ \color{#c00}{2}\:\!m &=&\ \ 2 &+&\ 1 &+& \frac{2}{3} &+&\, \color{#0a0}{\frac{1}{2}} &+& \frac{2}{5} &+& \frac{1}{3} &+& \frac{2}{7}^\phantom{M^M}\\
&\Rightarrow\ & -\color{#0a0}{\frac{1}{2}}\ \ &=&\ \ 2 &+&\ 1 &+& \frac{2}{3} &-&\rm \color{#c00}{2}\:\!m  &+& \frac{2}{5} &+& \frac{1}{3} &+& \frac{2}{7}^\phantom{M^M}
\end{eqnarray}$$
All denom's in the prior fractions are odd so they sum to fraction with odd denom $\rm\,d\, |\, 3\cdot 5\cdot 7$.
Note $ $ Said $\rm\color{darkorange}{uniqueness}$ has easy proof: if  $\rm\:j\:\! 2^K$ is in the interval $\rm\,[1,n]\,$ then so too is $\,\rm \color{#0a0}{2^K}\! \le\, j\:\!2^K.\,$ But if $\,\rm j\ge 2\,$ then the interval contains $\rm\,2^{K+1}\!= 2\cdot\! 2^K\! \le  j\:\!2^K,\,$ contra maximality of $\,\rm K$.
The argument is more naturally expressed using valuation theory, but I purposely avoided that because Anton requested an "elementary" solution. The above proof can easily be made comprehensible to a high-school student.
Generally we can similarly prove that a sum of fractions is nonintegral if the highest power of  a prime $\,p\,$ in any denominator occurs in $\rm\color{darkorange}{exactly\ one}$ denominator, e.g. see the Remark here where I explain how it occurs in a trickier multiplicative form (from a contest problem). In valuation theory, this is a special case of a basic result on the valuation of a sum (sometimes called the "dominance lemma" or similar). Another common application occurs when the sum of fractions arises from the evaluation of a polynomial, e.g. see here and its comment.


Question:
I am currently looking for a system which will allow me to version both the code and the data in my research.
I think my way of analyzing data is not uncommon, and this will be useful for many people doing bioinformatics and aiming for the reproducibility.
Here are the requrements:

Analysis is performed on multiple machines (local, cluster, server).
All the code is transparently synchronized between the machines.
Source code versioning.
Generated data versioning.
Support for large number of small generated files (>10k). These also could be deleted.
Support for large files (>1Gb). At some point old generated files can  permanently deleted. It would be insane to have transparent synchronization of those, but being able to synchronize them on demand would be nice.

So far I am using git + rsync/scp. But there are several downsides to it.

Synchronization between multiple machines is a bit tedious, i.e. you have to git pull before you start working and git push after each update. I can live with that.
You are not supposed to store large generated data files or large number of files inside your repository.
Therefore I have to synchronize data files manually using rsync, which is error prone.

There is something called git annex. It seems really close to what I need. But:

A bit more work than git, but that's ok.
Unfortunately it seems it does not work well with the large number of files. Often I have more that 10k small files in my analysis. There are some tricks to improve indexing, but it doesn't solve the issue. What I need is one symlink representing the full contents of directory.

One potential solution is to use Dropbox or something similar (like syncthing) in combination with git. But the downside is there will be no connection between the source code version and the data version.
Is there any versioning system for the code and the data meeting the requirements you can recommend?

There is a couple of points to consider here, which I outline below. The goal here should be to find a workflow that is minimally intrusive on top of already using git.
As of yet, there is no ideal workflow that covers all use cases, but what I outline below is the closest I could come to it.
Reproducibility is not just keeping all your data
You have got your raw data that you start your project with.
All other data in your project directory should never just "be there", but have some record of where it comes from. Data processing scripts are great for this, because they already document how you went from your raw to your analytical data, and then the files needed for your analyses.
And those scripts can be versioned, with an appropriate single entry point of processing (e.g. a Makefile that describes how to run your scripts).
This way, the state of all your project files is defined by the raw data, and the version of your processing scripts (and versions of external software, but that's a whole different kind of problem).
What data/code should and should not be versioned
Just as you would not version generated code files, you should not want to version 10k intermediary data files that you produced when performing your analyses. The data that should be versioned is your raw data (at the start of your pipeline), not automatically generated files.
You might want to take snapshots of your project directory, but not keep every version of every file ever produced. This already cuts down your problem by a fair margin.
Approach 1: Actual versioning of data
For your raw or analytical data, Git LFS (and alternatively Git Annex, that you already mention) is designed to solve exactly this problem: add tracking information of files in your Git tree, but do not store the content of those files in the repository (because otherwise it would add the size of a non-diffable file with every change you make).
For your intermediate files, you do the same as you would do with intermediate code files: add them to your .gitignore and do not version them.
This begs a couple of considerations:

Git LFS is a paid service from Github (the free tier is limited to 1 GB of storage/bandwidth per month, which is very little), and it is more expensive than other comparable cloud storage solutions. You could consider paying for the storage at Github or running your own LFS server (there is a reference implementation, but I assume this would still be a substantial effort)
Git Annex is free, but it replaces files by links and hence changes time stamps, which is a problem for e.g. GNU Make based workflows (major drawback for me). Also, fetching of files needs to be done manually or via a commit hook

Approach 2: Versioning code only, syncing data
If your analytical data stays the same for most of your analyses, so the actual need to version it (as opposed to back up and document data provenance, which is essential) may be limited.
The key to get this this working is to put all data files in your .gitignore and ignore all your code files in rsync, with a script in your project root (extensions and directories are an example only):
#!/bin/bash
cd $(dirname $0)
rsync -auvr \
    --exclude "*.r" \
    --include "*.RData" \
    --exclude "dir with huge files that you don't need locally" \
    yourhost:/your/project/path/* .

The advantage here is that you don't need to remember the rsync command you are running. The script itself goes into version control.
This is especially useful if you do your heavy processing on a computing cluster but want to make plots from your result files on your local machine. I argue that you generally don't need bidirectional sync.


Question:
I'm using Python Keras package for neural network. This is the link. Is batch_size equals to number of test samples? From Wikipedia we have this information:

However, in other cases, evaluating the sum-gradient may require
  expensive evaluations of the gradients from all summand functions.
  When the training set is enormous and no simple formulas exist,
  evaluating the sums of gradients becomes very expensive, because
  evaluating the gradient requires evaluating all the summand functions'
  gradients. To economize on the computational cost at every iteration,
  stochastic gradient descent samples a subset of summand functions at
  every step. This is very effective in the case of large-scale machine
  learning problems.

Above information is describing test data? Is this same as batch_size in keras (Number of samples per gradient update)?

The batch size defines the number of samples that will be propagated through the network.
For instance, let's say you have 1050 training samples and you want to set up a batch_size equal to 100. The algorithm takes the first 100 samples (from 1st to 100th) from the training dataset and trains the network. Next, it takes the second 100 samples (from 101st to 200th) and trains the network again. We can keep doing this procedure until we have propagated all samples through of the network. Problem might happen with the last set of samples. In our example, we've used 1050 which is not divisible by 100 without remainder. The simplest solution is just to get the final 50 samples and train the network.
Advantages of using a batch size < number of all samples:

It requires less memory. Since you train the network using fewer samples, the overall training procedure requires less memory. That's especially important if you are not able to fit the whole dataset in your machine's memory.
Typically networks train faster with mini-batches. That's because we update the weights after each propagation. In our example we've propagated 11 batches (10 of them had 100 samples and 1 had 50 samples) and after each of them we've updated our network's parameters. If we used all samples during propagation we would make only 1 update for the network's parameter.

Disadvantages of using a batch size < number of all samples:

The smaller the batch the less accurate the estimate of the gradient will be. In the figure below, you can see that the direction of the mini-batch gradient (green color) fluctuates much more in comparison to the direction of the full batch gradient (blue color).

Stochastic is just a mini-batch with batch_size equal to 1. In that case, the gradient changes its direction even more often than a mini-batch gradient.


Question:
What are some surprising equations/identities that you have seen, which you would not have expected?
This could be complex numbers, trigonometric identities, combinatorial results, algebraic results, etc.
I'd request to avoid 'standard' / well-known results like $ e^{i \pi} + 1 = 0$.
Please write a single identity (or group of identities) in each answer.
I found this list of Funny identities, in which there is some overlap.

This one by Ramanujan gives me the goosebumps:
$$
\frac{2\sqrt{2}}{9801} \sum_{k=0}^\infty \frac{ (4k)! (1103+26390k) }{ (k!)^4 396^{4k} } = \frac1{\pi}.
$$

P.S. Just to make this more intriguing, define the fundamental unit $U_{29} = \frac{5+\sqrt{29}}{2}$ and fundamental solutions to Pell equations,
$$\big(U_{29}\big)^3=70+13\sqrt{29},\quad \text{thus}\;\;\color{blue}{70}^2-29\cdot\color{blue}{13}^2=-1$$
$$\big(U_{29}\big)^6=9801+1820\sqrt{29},\quad \text{thus}\;\;\color{blue}{9801}^2-29\cdot1820^2=1$$
$$2^6\left(\big(U_{29}\big)^6+\big(U_{29}\big)^{-6}\right)^2 =\color{blue}{396^4}$$
then we can see those integers all over the formula as,
$$\frac{2 \sqrt 2}{\color{blue}{9801}} \sum_{k=0}^\infty \frac{(4k)!}{k!^4} \frac{29\cdot\color{blue}{70\cdot13}\,k+1103}{\color{blue}{(396^4)}^k} =  \frac{1}{\pi} $$
Nice, eh?


Question:
Find a positive integer solution $(x,y,z,a,b)$ for which
$$\frac{1}{x}+ \frac{1}{y} + \frac{1}{z} + \frac{1}{a} + \frac{1}{b} = 1\;.$$
Is your answer the only solution? If so, show why.
I was surprised that a teacher would assign this kind of problem to a 5th grade child. (I'm a college student tutor) This girl goes to a private school in a wealthy neighborhood.
Please avoid the trivial $x=y=z=a=b=5$. Try looking for a solution where $ x \neq y \neq z \neq a \neq b$ or if not, look for one where one variable equals to another, but explain your reasoning. The girl was covering "unit fractions" in her class.

The perfect number $28=1+2+4+7+14$ provides a solution:
$$\frac1{28}+\frac1{14}+\frac17+\frac14+\frac12=\frac{1+2+4+7+14}{28}=1\;.$$
If they’ve been doing unit (or ‘Egyptian’) fractions, I’d expect some to see that since $\frac16+\frac13=\frac12$, $$\frac16+\frac16+\frac16+\frac16+\frac13=1$$ is a solution, though not a much more interesting one than the trivial solution. The choice of letters might well suggest the solution
$$\frac16+\frac16+\frac16+\frac14+\frac14\;.$$
A little playing around would show that $\frac14+\frac15=\frac9{20}$, which differs from $\frac12$ by just $\frac1{20}$; that yields the solution
$$\frac1{20}+\frac15+\frac14+\frac14+\frac14\;.$$
If I were the teacher, I’d hope that some kids would realize that since the average of the fractions is $\frac15$, in any non-trivial solution at least one denominator must be less than $5$, and at least one must be greater than $5$. Say that $x\le y\le z\le a\le b$. Clearly $x\ge 2$, so let’s try $x=2$. Then we need to solve
$$\frac1y+\frac1z+\frac1a+\frac1b=\frac12\;.$$
Now $y\ge 3$. Suppose that $y=3$; then $$\frac1z+\frac1a+\frac1b=\frac16\;.$$
Now $1,2$, and $3$ all divide $36$, and $\frac16=\frac6{36}$, so we can write
$$\frac1{36}+\frac1{18}+\frac1{12}=\frac{1+2+3}{36}=\frac6{36}=\frac16\;,$$
and we get another ‘nice’ solution,
$$\frac12+\frac13+\frac1{12}+\frac1{18}+\frac1{36}\;.$$