Question:
As cited in an answer to this question, the ground state electronic configuration of niobium is:

$\ce{Nb: [Kr] 5s^1 4d^4}$

Why is that so? What factors stabilize this configuration, compared to the obvious $\ce{5s^2 4d^3}$ (Aufbau principle), or the otherwise possible $\ce{5s^0 4d^5}$ (half-filled shell)?

There is an explanation to this that can be generalized, which dips a little into quantum chemistry, which is known as the idea of pairing energy. I'm sure you can look up the specifics, but basically in comparing the possible configurations of $\ce{Nb}$, we see the choice of either pairing electrons at a lower energy, or of separating them at higher energy, as seen below:
d:   ↿ ↿ ↿ _ _        ↿ ↿ ↿ ↿ _        ↿ ↿ ↿ ↿ ↿     ^
                 OR               OR               |
s:   ⥮               ↿                _            Energy gap (E)

The top row is for the d-orbitals, which are higher in energy, and the bottom row is for the s-orbital, which is lower in energy. There is a quantifiable energy gap between the two as denoted on the side (unique for every element). As you may know, electrons like to get in the configuration that is lowest in energy. At first glance, that might suggest putting as many electrons in the s-orbital (lower energy) as possible, and then filling the rest in the d-orbital. This is known as the Aufbau principle and is widely taught in chemistry classes. It's not wrong, and works most of the time, but the story doesn't end there. There is a cost to pairing the electrons in the lower orbital, two costs actually, which I will define now:
Repulsion energy: Pretty simple, the idea that e- repel, and having two of them in the same orbital will cost some energy. Normally counted as 1 C for every pair of electrons.
Exchange energy: This is a little tricky, and probably the main reason this isn't taught until later in your chemistry education. Basically (due to quantum chemistry which I won't bore you with), there is a beneficial energy associated with having pairs of like energy, like spin electrons. Basically, for every pair of electrons at the same energy level (or same orbital shell in this case) and same spin (so, if you had 2 e- in the same orbital, no dice, since they have to be opposite spin), you accrue 1 K exchange energy, which is a stabilizing energy. (This is very simplified, but really "stabilizing energy" is nothing more than negative energy. I hope your thermodynamics is in good shape!) The thing with exchange (or K) energy is that you get one for every pair, so in the case:
↿ ↿ ↿

from say a p-subshell, you would get 3 K, for each pair, while from this example:
⥮ ↿ ↿ ↿ ↿

from a $\ce{d^6}$, you would get 10 K (for each unique pair, and none for the opposite spin e-)
This K is quantifiable as well (and like the repulsion energy is unique for each atom).
Thus, the combination of these two energies when compared to the band gap determines the state of the electron configuration. Using the example we started with:
d:   ↿ ↿ ↿ _ _         ↿ ↿ ↿ ↿ _         ↿ ↿ ↿ ↿ ↿    ^
s:   ⥮           OR   ↿           OR   _            |
PE:  3K + 1C          6K + 0C          10K + 0C     Energy gap (E)

You can see from the example that shoving 1 e- up from the s to the d-subshell results in a loss of 1C (losing positive or "destabilizing" repulsive energy) and gaining 3K (gaining negative or "stabilizing" exchange energy). Therefore, if the sum of these two is greater than the energy gap (i.e. 3K - 1C > E) then the electron will indeed be found in the d shell in $\ce{Nb}$'s ground state. Which is indeed the case for $\ce{Nb}$.
Next, lets look at perhaps exciting the second s e- up to the d-subshell. We gain 4 additional K but don't lose any C, and we must again overcome the energy gap for this electron to be found in the d-subshell.
It turns out that for $\ce{Nb}$: 4K + 0C < E  (remember that C is considered a negative value, which we're not losing any of), so $\ce{Nb}$ is ultimately found in the $\ce{5s^1 4d^4}$ configuration.


Question:
Which software provides a good workflow from simple plotting of a few datapoints up to the creation of publication level graphics with detailed styles, mathematical typesetting and "professional quality"?
This is a bit related to the question of David (What attributes make a figure professional quality?) but the focus is not on the attributes but on the software or general the workflow to get there. I have superficial experience with a number of programs, Gnuplot, Origin, Matplotlib, TikZ/PGFplot, Qtiplot but doing data analysis and nice figures at the same time seems rather hard to do.
Is there some software that allows this or should I just dig deeper in one of the packages?
Edit: My current workflow is a mix of different components, which more or less work together but in total it is not really efficient and I think this is typical for a number of scientists at an university lab. Typically it is a chain starting from the experiment to the publication like this:

Get experimental data (usually in ASCII form, but with different layout, e.g. headers, comments, number of columns)
Quick plot of the data to check whether nothing went wrong in Origin, Gnuplot or arcane plot program written 20 years ago.
More detailed analysis of the data: subtracting background contributions, analysing dependencies and correlations, fitting with theoretical models. Many scientists use Origin for this task, some Matlab and Python/Scipy/Numpy usage is increasing.
Creating professional figures, this involves adjusting to journal guidelines, mathematical typesetting and general editing. At the moment I use Origin for this but it has several drawbacks (just try to get a linewidth of exactly 0.5pt, it is not possible). For combining/polishing figures I mainly use Adobe Illustrator, as it can handle im-/export of PDF documents nicely but I would prefer not having to go through two steps for each diagram.

I added an example of how it might look like in the end (as this has been created mostly by hand changing anything is painful and anything that provides an interface for example to set the linewidth for all elements would be nice):

If you have some experience with Python (or even not), I would recommend using the Python scientific software that is available (SciPy,Pandas),...) together with Matplotlib. Being a programming environment, you have full control over your data flows, data manipulations and plotting. You can also use the "full applications" Mayavi2 or  Veusz.


Question:
It is fine to say that for an object flying past a massive object, the spacetime is curved by the massive object, and so the object flying past follows the curved path of the geodesic, so it "appears" to be experiencing gravitational acceleration. Do we also say along with it, that the object flying past in reality exeriences NO attraction force towards the massive object? Is it just following the spacetime geodesic curve while experiencing NO attractive force?
Now come to the other issue: Supposing two objects are at rest relative to each other, ie they are not following any spacetime geodesic. Then why will they experience gravitational attraction towards each other? E.g. why will an apple fall to earth? Why won't it sit there in its original position high above the earth? How does the curvature of spacetime cause it to experience an attraction force towards the earth, and why would we need to exert a force in reverse direction to prevent it from falling? How does the curvature of spacetime cause this?
When the apple was detatched from the branch of the tree, it was stationary, so it did not have to follow any geodesic curve. So we cannot just say that it fell to earth because its geodesic curve passed through the earth. Why did the spacetime curvature cause it to start moving in the first place?

To really understand this you should study the differential geometry of geodesics in curved spacetimes. I'll try to provide a simplified explanation.
Even objects "at rest" (in a given reference frame) are actually moving through spacetime, because spacetime is not just space, but also time: apple is "getting older" - moving through time. The "velocity" through spacetime is called a four-velocity and it is always equal to the speed of light. Spacetime in gravitation field is curved, so the time axis (in simple terms) is no longer orthogonal to the space axes. The apple moving first only in the time direction (i.e. at rest in space) starts accelerating in space thanks to the curvature (the "mixing" of the space and time axes) - the velocity in time becomes velocity in space. The acceleration happens because the time flows slower when the gravitational potential is decreasing. Apple is moving deeper into the graviational field, thus its velocity in the "time direction" is changing (as time gets slower and slower). The four-velocity is conserved (always equal to the speed of light), so the object must accelerate in space. This acceleration has the direction of decreasing gravitational gradient.
Edit - based on the comments I decided to clarify what the four-velocity is:
4-velocity is a four-vector, i.e. a vector with 4 components. The first component is the "speed through time" (how much of the coordinate time elapses per 1 unit of proper time). The remaining 3 components are the classical velocity vector (speed in the 3 spatial directions).
$$ U=\left(c\frac{dt}{d\tau},\frac{dx}{d\tau},\frac{dy}{d\tau},\frac{dz}{d\tau}\right) $$
When you observe the apple in its rest frame (the apple is at rest - zero spatial velocity), the whole 4-velocity is in the "speed through time". It is because in the rest frame the coordinate time equals the proper time, so $\frac{dt}{d\tau} = 1$.
When you observe the apple from some other reference frame, where the apple is moving at some speed, the coordinate time is no longer equal to the proper time. The time dilation causes that there is less proper time measured by the apple than the elapsed coordinate time (the time of the apple is slower than the time in the reference frame from which we are observing the apple). So in this frame, the "speed through time" of the apple is more than the speed of light ($\frac{dt}{d\tau} > 1$), but the speed through space is also increasing.
The magnitude of the 4-velocity always equals c, because it is an invariant (it does not depend on the choice of the reference frame). It is defined as:
$$ \left\|U\right\| =\sqrt[2]{c^2\left(\frac{dt}{d\tau}\right)^2-\left(\frac{dx}{d\tau}\right)^2-\left(\frac{dy}{d\tau}\right)^2-\left(\frac{dz}{d\tau}\right)^2} $$
Notice the minus signs in the expression - these come from the Minkowski metric. The components of the 4-velocity can change when you switch from one reference frame to another, but the magnitude stays unchanged (all the changes in components "cancel out" in the magnitude).


Question:
Suppose that I'm working on a scientific code in C++. In a recent discussion with a colleague, it was argued that expression templates could be a really bad thing, potentially making software compilable only on certain versions of gcc. Supposedly, this problem has affected a few scientific codes, as alluded to in the subtitles of this parody of Downfall. (These are the only examples I know of, hence the link.)
However, other people have argued that expression templates are useful because they can yield performance gains, as in this paper in SIAM Journal of Scientific Computing, by avoiding storage of intermediate results in temporary variables.
I don't know a whole lot about template metaprogramming in C++, but I do know that it is one approach used in automatic differentiation and in interval arithmetic, which is how I got into a discussion about expression templates. Given both the potential advantages in performance and the potential disadvantages in maintenance (if that's even the right word), when should I use C++ expression templates in computational science, and when should I avoid them?

My problem with expression templates is that they are a very leaky abstraction. You spend a lot of work writing very complicated code to do a simple task with nicer syntax. But if you want to change the algorithm, you have to mess with the dirty code and if you slip up with types or syntax, you get completely unintelligible error messages. If your application maps perfectly to a library based on expression templates, then it might be worth considering, but if you aren't sure, I would recommend just writing normal code. Sure, the high level code is less pretty, but you can just do what needs to be done. As a benefit, compilation time and binary sizes will go way down and you won't have to cope with huge variance in performance due to compiler and compilation flag choice.


Question:
The datasheet of the 24LC256 EEPROM states that:

The SDA bus requires a pull-up resistor to VCC (typical 10 kΩ for 100 kHz, 2 kΩ for 400 kHz and 1 MHz).

I thought that any resistor with a kΩ value would do the job (and it seems that my EEPROM works fine at different frequencies with a 10 kΩ resistor).
My questions are:

is there a correct value for pull-up resistors ?
is there a law/rule to determine this value ?
how do different resistance values affect the I²C data bus ?

The correct pullup resistance for the I2C bus depends on the total capacitance on the bus
and the frequency you want to operate the bus at.
The formula from the ATmega168 datasheet (which I believe comes from the official I2C spec) is --
$$\text{Freq}<100\text{kHz} \implies R_{\text{min}}=\frac{V_{cc}-0.4\text{V}}{3\text{mA}}, R_{\text{max}}=\frac{1000\text{ns}}{C_{\text{bus}}}$$
$$\text{Freq}>100\text{kHz} \implies R_{\text{min}}=\frac{V_{cc}-0.4\text{V}}{3\text{mA}}, R_{\text{max}}=\frac{300\text{ns}}{C_{\text{bus}}}$$
The Microchip 24LC256 specifies a maximum pin capacitance of 10pF (which is fairly
typical). Count up the number of devices you have in parallel on the bus and
use the formula above to calculate a range of values that will work.
If you are powering off of batteries I would use values that are at the high
end of the range. If there are no power limits on the power source or
power dissipation issues in the ICs I would use values on the lower end
of the range.
I sell some kits with an I2C RTC (DS1337). I include 4K7 resistors in the kit which
seems like a reasonable compromise for most users.


Question:
Given Newton's third law, why is there motion at all? Should not all forces even themselves out, so nothing moves at all?
When I push a table using my finger, the table applies the same force onto my finger like my finger does on the table just with an opposing direction, nothing happens except that I feel the opposing force.
But why can I push a box on a table by applying force ($F=ma$) on one side, obviously outbalancing the force the box has on my finger and at the same time outbalancing the friction the box has on the table?
I obviously have the greater mass and acceleration as for example the matchbox on the table and thusly I can move it, but shouldn't the third law prevent that from even happening? Shouldn't the matchbox just accommodate to said force and applying the same force to me in opposing direction?

I think it's a great question, and enjoyed it very much when I grappled with it myself.
Here's a picture of some of the forces in this scenario.$^\dagger$ The ones that are the same colour as each other are pairs of equal magnitude, opposite direction forces from Newton's third law. (W and R are of equal magnitude in opposite directions, but they're acting on the same object - that's Newton's first law in action.)

While $F_\text{matchbox}$ does press back on my finger with an equal magnitude to $F_\text{finger}$, it's no match for $F_\text{muscles}$ (even though I've not been to the gym in years).
At the matchbox, the forward force from my finger overcomes the friction force from the table. Each object has an imbalance of forces giving rise to acceleration leftwards.
The point of the diagram is to make clear that the third law makes matched pairs of forces that act on different objects. Equilibrium from Newton's first or second law is about the resultant force at a single object.
$\dagger$ (Sorry that the finger doesn't actually touch the matchbox in the diagram. If it had, I wouldn't have had space for the important safety notice on the matches. I wouldn't want any children to be harmed because of a misplaced force arrow. Come to think of it, the dagger on this footnote looks a bit sharp.)


Question:
$$\sum_{n=1}^\infty\frac1{n^s}$$
only converges to $\zeta(s)$ if $\text{Re}(s)>1$.
Why should analytically continuing to $\zeta(-1)$ give the right answer?

there are many ways to see that your result is the right one. What does the right one mean?
It means that whenever such a sum appears anywhere in physics - I explicitly emphasize that not just in string theory, also in experimentally doable measurements of the Casimir force (between parallel metals resulting from quantized standing electromagnetic waves in between) - and one knows that the result is finite, the only possible finite part of the result that may be consistent with other symmetries of the problem (and that is actually confirmed experimentally whenever it is possible) is equal to $-1/12$.
It's another widespread misconception (see all the incorrect comments right below your question) that the zeta-function regularization is the only way how to calculate the proper value. Let me show a completely different calculation - one that is a homework exercise in Joe Polchinski's "String Theory" textbook.
Exponential regulator method
Add an exponentially decreasing regulator to make the sum convergent - so that the sum becomes
$$ S = \sum_{n=1}^{\infty} n e^{-\epsilon n} $$
Note that this is not equivalent to generalizing the sum to the zeta-function. In the zeta-function, the $n$ is the base that is exponentiated to the $s$th power. Here, the regulator has $n$ in the exponent. Obviously, the original sum of natural numbers is obtained in the $\epsilon\to 0$ limit of the formula for $S$. In physics, $\epsilon$ would be viewed as a kind of "minimum distance" that can be resolved.
The sum above may be exactly evaluated and the result is (use Mathematica if you don't want to do it yourself, but you can do it yourself)
$$ S = \frac{e^\epsilon}{(e^\epsilon-1)^2} $$
We will only need some Laurent expansion around $\epsilon = 0$.
$$ S = \frac{1+\epsilon+\epsilon^2/2 + O(\epsilon^3)}{(\epsilon+\epsilon^2/2+\epsilon^3/6+O(\epsilon^4))^2} $$
We have
$$ S = \frac{1}{\epsilon^2} \frac{1+\epsilon+\epsilon^2/2+O(\epsilon^3)}{(1+\epsilon/2+\epsilon^2/6+O(\epsilon^3))^2} $$
You see that the $1/\epsilon^2$ leading divergence survives and the next subleading term cancels. The resulting expansion may be calculated with this Mathematica command
1/epsilon^2 * Series[epsilon^2 Sum[n Exp[-n epsilon], {n, 1, Infinity}], {epsilon, 0, 5}]
and the result is
$$ \frac{1}{\epsilon^2} - \frac{1}{12} + \frac{\epsilon^2}{240} + O(\epsilon^4) $$
In the $\epsilon\to 0$ limit we were interested in, the $\epsilon^2/240$ term as well as the smaller ones go to zero and may be erased. The leading divergence $1/\epsilon^2$ may be and must be canceled by a local counterterm - a vacuum energy term. This is true for the Casimir effect in electromagnetism (in this case, the cancelled pole may be interpreted as the sum of the zero-point energies in the case that no metals were bounding the region), zero-point energies in string theory, and everywhere else. The cancellation of the leading divergence is needed for physics to be finite - but one may guarantee that the counterterm won't affect the finite term, $-1/12$, which is the correct result of the sum.
In physics applications, $\epsilon$ would be dimensionful and its different powers are sharply separated and may be treated individually. That's why the local counterterms may eliminate the leading divergence but don't affect the finite part. That's also why you couldn't have used a more complex regulator, like $\exp(-(\epsilon+\epsilon^2)n)$.
There are many other, apparently inequivalent ways to compute the right value of the sum. It is not just the zeta function.
Euler's method
Let me present one more, slightly less modern, method that was used by Leonhard Euler to calculate that the sum of natural numbers is $-1/12$. It's of course a bit more heuristic but his heuristic approach showed that he had a good intuition and the derivation could be turned into a modern physics derivation, too.
We will work with two sums,
$$ S = 1+2+3+4+5+\dots, \quad T = 1-2+3-4+5-\dots $$
Extrapolating the geometric and similar sums to the divergent (and, in this case, marginally divergent) domain of values of $x$, the expression $T$ may be summed according to the Taylor expansion
$$ \frac{1}{(1+x)^2} = 1 - 2x + 3x^2 -4x^3 + \dots $$
Substitute $x=1$ to see that $T=+1/4$. The value of $S$ is easily calculated now:
$$ T = (1+2+3+\dots) - 2\times (2+4+6+\dots) = (1+2+3+\dots) (1 - 4) = -3S$$
so $S=-T/3=-1/12$.
A zeta-function calculation
A somewhat unusual calculation of $\zeta(-1)=-1/12$ of mine may be found in the Pictures of Yellows Roses, a Czech student journal. The website no longer works, although a working snapshot of the original website is still available through the WebArchive (see this link). A 2014 English text with the same evaluation at the end can be found at The Reference Frame.
The comments were in Czech but the equations represent bulk of the language that really matters, so the Czech comments shouldn't be a problem. A new argument (subscript) $s$ is added to the zeta function. The new function is the old zeta function for $s=0$ and for $s=1$, it only differs by one. We Taylor expand around $s=0$ to get to $s=1$ and we find out that only a finite number of terms survives if the main argument $x$ is a non-positive integer. The resulting recursive relations for the zeta function allow us to compute the values of the zeta-function at integers smaller than $1$, and prove that the function vanishes at negative even values of $x$.


Question:
Adaptive thresholding has been discussed in a few questions earlier:
Adaptive Thresholding for liver segmentation using Matlab
What are the best algorithms for document image thresholding in this example?
Of course, there are many algorithms for Adaptive thresholding. I want to know which ones you have found most effective and useful.
Which Adaptive algorithms you have used the most and for which application; how do you come to choose this algorithm?

I do not think mine will be a complete answer, but I'll offer what I know and since this is a community edited site, I hope somebody will give a complimentary answer soon :)
Adaptive thresholding methods are those that do not use the same threshold throughout the whole image.
But, for some simpler usages, it is sometimes enough to just pick a threshold with a method smarter than the most simple iterative method. Otsu's method is a popular thresholding method that assumes the image contains two classes of pixels - foreground and background, and has a bi-modal histogram. It then attempts to minimize their combined spread (intra-class variance).
The simplest algorithms that can be considered truly adaptive thresholding methods would be the ones that split the image into a grid of cells and then apply a simple thresholding method (e.g. iterative or Otsu's method) on each cell treating it as a separate image (and presuming a bi-modal histogram). If a sub-image can not be thresholded good the threshold from one of the neighboring cells can be used.
Alternative approach to finding the local threshold is to statistically examine the intensity values of the local neighborhood of each pixel. The threshold is different for each pixel and calculated from it's local neighborhood (a median, average, and other choices are possible). There is an implementation of this kind of methods included in OpenCV library in the cv::adaptiveThresholding function.
I found another similar method called Bradley Local Thresholding. It also examines the neighborhood of each pixel, setting the brightnes to black if the pixels brightness is t percent lower than the average brightness of surrounding pixels. The corresponding paper can be found here.
This stackoverflow answer mentiones a local (adaptive) thresholding method called Niblack but I have not heard of it before.
Lastly, there is a method I have used in one of my previous smaller projects, called Image Thresholding by Variational Minimax Optimization. It is an iterative method, based on optimizing an energy function that is a nonlinear combination of two components. One component aims to calculate the threshold based on the position of strongest intensity changes in the image. The other component aims to smooth the threshold at the (object)border areas. It has proven fairly good on images of analog instruments (various shading and reflection from glass/plastic present), but required a careful choice of the number of iterations.
Late edit:
Inspired by the comment to this answer. There is one more way I know of to work around uneven lighting conditions. I will write here about bright objects on a dark background, but the same reasoning can be applied if the situation is reverse. Threshold the white top-hat transform of the image with a constant threshold instead of the original image. A white top hat of an image is nothing but a difference between the image $f$ and it's opening $\gamma(f)$. As further explanation let me offer a quote from P. Soille: Morphological Image Analysis:

An opening of the original image with a large square SE removes all relevant image structures but preserves the illumination function. The white top-hat of the original image or subtraction of the illumination function from the original image outputs an image with a homogeneous illumination.


Question:
In statistics and its various applications, we often calculate the covariance matrix, which is positive definite (in the cases considered) and symmetric, for various uses. Sometimes, we need the inverse of this matrix for various computations (quadratic forms with this inverse as the (only) center matrix, for example). Given the qualities of this matrix, and the intended uses, I wonder:
What is the best, in terms of numerical stability, way to go about computing or using (let's say for quadratic forms or matrix-vector multiplication in general) this inverse? Some factorization that can come in handy?

A Cholesky factorization makes the most sense for the best stability and speed when you are working with a covariance matrix, since the covariance matrix will be positive semi-definite  symmetric matrix. Cholesky is a natural here. BUT...
IF you intend to compute a Cholesky factorization, before you ever compute the covariance matrix, do yourself a favor. Make the problem maximally stable by computing a QR factorization of your matrix. (A QR is fast too.) That is, if you would compute the covariance matrix as
$$
C = A^{T} A
$$
where $A$ has had the column means removed, then see that when you form $C$, it squares the condition number. So better is to form the QR factors of $A$ rather than explicitly computing a Cholesky factorization of $A^{T}A$.
$$
A = QR
$$
Since Q is orthogonal,
$$
\begin{align}
C &= (QR)^{T} QR \\
&= R^T Q^T QR \\
&= R^T I R \\
&= R^{T} R
\end{align}
$$
Thus we get the Cholesky factor directly from the QR factorization, in the form of $R^{T}$. If a $Q$-less QR factorization is available, this is even better since you don't need $Q$. A $Q$-less QR is a fast thing to compute, since $Q$ is never generated. It becomes merely a sequence of Householder transformations. (A column pivoted, $Q$-less QR would logically be even more stable, at the cost of some extra work to choose the pivots.)
The great virtue of using the QR here is it is highly numerically stable on nasty problems. Again, this is because we never had to form the covariance matrix directly to compute the Cholesky factor. As soon as you form the product $A^{T}A$, you square the condition number of the matrix. Effectively, you lose information down in the parts of that matrix where you originally had very little information to start with.
Finally, as another response points out, you don't even need to compute and store the inverse at all, but use it implicitly in the form of backsolves on triangular systems.


Question:
In speech recognition, the front end generally does signal processing to allow feature extraction from the audio stream. A discrete Fourier transform (DFT) is applied twice in this process. The first time is after windowing; after this Mel binning is applied and then another Fourier transform.
I've noticed however, that it is common in speech recognizers (the default front end in CMU Sphinx, for example) to use a discrete cosine transform (DCT) instead of a DFT for the second operation. What is the difference between these two operations? Why would you do DFT the first time and then a DCT the second time?

The Discrete Fourier Transform (DFT) and Discrete Cosine Transform (DCT) perform similar functions: they both decompose a finite-length discrete-time vector into a sum of scaled-and-shifted basis functions. The difference between the two is the type of basis function used by each transform; the DFT uses a set of harmonically-related complex exponential functions, while the DCT uses only (real-valued) cosine functions.
The DFT is widely used for general spectral analysis applications that find their way into a range of fields. It is also used as a building block for techniques that take advantage of properties of signals' frequency-domain representation, such as the overlap-save and overlap-add fast convolution algorithms.
The DCT is frequently used in lossy data compression applications, such as the JPEG image format. The property of the DCT that makes it quite suitable for compression is its high degree of "spectral compaction;" at a qualitative level, a signal's DCT representation tends to have more of its energy concentrated in a small number of coefficients when compared to other transforms like the DFT. This is desirable for a compression algorithm; if you can approximately represent the original (time- or spatial-domain) signal using a relatively small set of DCT coefficients, then you can reduce your data storage requirement by only storing the DCT outputs that contain significant amounts of energy.


Question:
There are many tutorials that use a pull-up or pull-down resistor in conjunction with a switch to avoid a floating ground, e.g.

Many of these projects use a 10K resistor, merely remarking that it is a good value.
Given a particular circuit, how do I determine the appropriate value for a pull-down resistor?  Can it be calculated, or is it best determined by experimentation?

Use 10 kΩ, it's a good value.
For more detail, we have to look at what a pullup does.  Let's say you have a pushbutton you want to read with a microcontroller.  The pushbutton is a momentary SPST (Single Pole Single Throw) switch.  It has two connection points which are either connected or not.  When the button is pressed, the two points are connected (switch is closed).  When released, they are not connected (switch is open).  Microcontrollers don't inherently detect connection or disconnection.  What they do sense is a voltage.  Since this switch has only two states it makes sense to use a digital input, which is after all designed to be only in one of two states.  The micro can sense which state a digital input is in directly.
A pullup helps convert the open/closed connection of the switch to a low or high voltage the microcontroller can sense.  One side of the switch is connected to ground and the other to the digital input.  When the switch is pressed, the line is forced low because the switch essentially shorts it to ground.  However, when the switch is released, nothing is driving the line to any particular voltage.  It could just stay low, pick up other nearby signals by capacitive coupling, or eventually float to a specific voltage due to the tiny bit of leakage current thru the digital input.  The job of the pullup resistor is to provide a positive guaranteed high level when the switch is open, but still allow the switch to safely short the line to ground when closed.
There are two main competing requirements on the size of the pullup resistor.  It has to be low enough to solidly pull the line high, but high enough to not cause too much current to flow when the switch is closed.  Both those are obviosly subjective and their relative importance depends on the situation.  In general, you make the pullup just low enough to make sure the line is high when the switch is open, given all the things that might make the line low otherwise.
Let's look at what it takes to pull up the line.  Looking only at the DC requirement uncovers the leakage current of the digital input line.  The ideal digital input has infinite impedance.  Real ones don't, of course, and the extent they are not ideal is usually expressed as a maximum leakage current that can either come out of or go into the pin.  Let's say your micro is specified for 1 µA maximum leakage on its digital input pins.  Since the pullup has to keep the line high, the worst case is assuming the pin looks like a 1 µA current sink to ground.  If you were to use a 1 MΩ pullup, for example, then that 1 µA would cause 1 Volt accross the 1 MΩ resistor.  Let's say this is a 5V system, so that means the pin is only guaranteed to be up to 4V.  Now you have to look at the digital input spec and see what the minimum voltage requirement is for a logic high level.  That can be 80% of Vdd for some micros, which would be 4V in this case.  Therefore a 1 MΩ pullup is right at the margin.  You need at least a little less than that for guaranteed correct behaviour due to DC considerations.
However, there are other considerations, and these are harder to quantify.  Every node has some capacitive coupling to all other nodes, although the magnitude of the coupling falls off with distance such that only nearby nodes are relevant.  If these other nodes have signals on them, these signals could couple onto your digital input.  A lower value pullup makes the line lower impedance, which reduces the amount of stray signal it will pick up.  It also gives you a higher minimum guaranteed DC level against the leakage current, so there is more room between that DC level and where the digital input might interpret the result as a logic low instead of the intended logic high.  So how much is enough?  Clearly the 1 MΩ pullup in this example is not enough (too high a resistance).  It's nearly impossible to guess coupling to nearby signals, but I'd want at least a order of magnitude margin over the minimum DC case.  That means I want a 100 kΩ pullup or lower at least, although if there is much noise around I'd want it to be lower.
There is another consideration driving the pullup lower, and that is rise time.  The line will have some stray capacitance to ground, so will exponentially decay towards the supply value instead of instantly going there.  Let's say all the stray capacitance adds up to 20 pF.  That times the 100 kΩ pullup is 2 µs.  It takes 3 time constants to get to 95% of the settling value, or 6 µs in this case.  That is of no consequence in human time so doesn't matter in this example, but if this were a digital bus line you wanted to run at 200 kHz data rate it wouldn't work.
Now lets look at the other competing consideration, which is the current wasted when the switch is pressed.  If this unit is running off of line power or otherwise handling substantial power, a few mA won't matter.  At 5V it takes 5 kΩ to draw 1 mA.  That's actually "a lot" of current in some cases, and well more than required due to the other considerations.  If this is a battery powered device and the switch could be on for a substantial fraction of the time, then every µA may matter and you have to think about this very carefully.  In some cases you might sample the switch periodically and only turn on the pullup for a short time around the sample to minimize current draw.
Other than special considerations like battery operation, 100 kΩ is high enough impedance to make me nervous about picking up noise.  1 mA of current wasted when the switch is on seems unnecessarily large.  So 500 µA, which means 10 kΩ impedance is about right.
Like I said, use 10 kΩ.  It's a good value.


Question:
I've recently heard a riddle, which looks quite simple, but I can't solve it.

A girl thinks of a number which is 1, 2, or 3, and a boy then gets to ask just one question about the number. The girl can only answer "Yes", "No", or "I don't know," and after the girl answers it, he knows what the number is. What is the question?

Note that the girl is professional in maths and knows EVERYTHING about these three numbers.

EDIT: The person who told me this just said the correct answer is:

 "I'm also thinking of a number. It's either 1 or 2. Is my number less than yours?"

"I am thinking of a number which is either 0 or 1. Is the sum of our numbers greater than 2?"


Question:
It seems that through various related questions here, there is consensus that the "95%" part of what we call a "95% confidence interval" refers to the fact that if we were to exactly replicate our sampling and CI-computation procedures  many times, 95% of thusly computed CIs would contain the population mean. It also seems to be the consensus that this definition does not permit one to conclude from a single 95%CI that there is a 95% chance that the mean falls somewhere within the CI. However, I don't understand how the former doesn't imply the latter insofar as, having imagined many CIs 95% of which contain the population mean, shouldn't our uncertainty (with regards to whether our actually-computed CI contains the population mean or not) force us to use the base-rate of the imagined cases (95%) as our estimate of the probability that our actual case contains the CI?
I've seen posts argue along the lines of "the actually-computed CI either contains the population mean or it doesn't, so its probability is either 1 or 0", but this seems to imply a strange definition of probability that is dependent on unknown states (i.e. a friend flips fair coin, hides the result, and I am disallowed from saying there is a 50% chance that it's heads).
Surely I'm wrong, but I don't see where my logic has gone awry...

Part of the issue is that the frequentist definition of a probability doesn't allow a nontrivial probability to be applied to the outcome of a particular experiment, but only to some fictitious population of experiments from which this particular experiment can be considered a sample.  The definition of a CI is confusing as it is a statement about this (usually) fictitious population of experiments, rather than about the particular data collected in the instance at hand. So part of the issue is one of the definition of a probability: The idea of the true value lying within a particular interval with probability 95% is inconsistent with a frequentist framework.
Another aspect of the issue is that the calculation of the frequentist confidence doesn't use all of the information contained in the particular sample relevant to bounding the true value of the statistic.  My question "Are there any examples where Bayesian credible intervals are obviously inferior to frequentist confidence intervals" discusses a paper by Edwin Jaynes which has some really good examples that really highlight the difference between confidence intervals and credible intervals.  One that is particularly relevant to this discussion is Example 5, which discusses the difference between a credible and a confidence interval for estimating the parameter of a truncated exponential distribution (for a problem in industrial quality control).  In the example he gives, there is enough information in the sample to be certain that the true value of the parameter lies nowhere in a properly constructed 90% confidence interval!
This may seem shocking to some, but the reason for this result is that confidence intervals and credible intervals are answers to two different questions, from two different interpretations of probability.
The confidence interval is the answer to the request: "Give me an interval that will bracket the true value of the parameter in $100p$% of the instances of an experiment that is repeated a large number of times."  The credible interval is an answer to the request: "Give me an interval that brackets the true value with probability $p$ given the particular sample I've actually observed." To be able to answer the latter request, we must first adopt either (a) a new concept of the data generating process or (b) a different concept of the definition of probability itself.
The main reason that any particular 95% confidence interval does not imply a 95% chance of containing the mean is because the confidence interval is an answer to a different question, so it is only the right answer when the answer to the two questions happens to have the same numerical solution.
In short, credible and confidence intervals answer different questions from different perspectives; both are useful, but you need to choose the right interval for the question you actually want to ask.  If you want an interval that admits an interpretation of a 95% (posterior) probability of containing the true value, then choose a credible interval (and, with it, the attendant conceptualization of probability), not a confidence interval.  The thing you ought not to do is to adopt a different definition of probability in the interpretation than that used in the analysis.
Thanks to @cardinal for his refinements!
Here is a concrete example, from David MaKay's excellent book "Information Theory, Inference and Learning Algorithms" (page 464):
Let the parameter of interest be $\theta$ and the data $D$, a pair of points $x_1$ and $x_2$ drawn independently from the following distribution:
$p(x|\theta) = \left\{\begin{array}{cl} 1/2 & x = \theta,\\1/2 & x = \theta + 1, \\ 0 & \mathrm{otherwise}\end{array}\right.$
If $\theta$ is $39$, then we would expect to see the datasets $(39,39)$, $(39,40)$, $(40,39)$ and $(40,40)$ all with equal probability $1/4$.  Consider the confidence interval
$[\theta_\mathrm{min}(D),\theta_\mathrm{max}(D)] = [\mathrm{min}(x_1,x_2), \mathrm{max}(x_1,x_2)]$.
Clearly this is a valid 75% confidence interval because if you re-sampled the data, $D = (x_1,x_2)$, many times then the confidence interval constructed in this way would contain the true value 75% of the time.
Now consider the data $D = (29,29)$.  In this case the frequentist 75% confidence interval would be $[29, 29]$.  However, assuming the model of the generating process is correct, $\theta$ could be 28 or 29 in this case, and we have no reason to suppose that 29 is more likely than 28, so the posterior probability is $p(\theta=28|D) = p(\theta=29|D) = 1/2$.  So in this case the frequentist confidence interval is clearly not a 75% credible interval as there is only a 50% probability that it contains the true value of $\theta$, given what we can infer about $\theta$ from this particular sample.
Yes, this is a contrived example, but if confidence intervals and credible intervals were not different, then they would still be identical in contrived examples.
Note the key difference is that the confidence interval is a statement about what would happen if you repeated the experiment many times, the credible interval is a statement about what can be inferred from this particular sample.


Question:
This is something that has been bugging me for a while, and I couldn't find any satisfactory answers online, so here goes:
After reviewing a set of lectures on convex optimization, Newton's method seems to be a far superior algorithm than gradient descent to find globally optimal solutions, because Newton's method can provide a guarantee for its solution, it's affine invariant, and most of all it converges in far fewer steps. Why is second-order optimization algorithms, such as Newton's method not as widely used as stochastic gradient descent in machine learning problems?

Gradient descent maximizes a function using knowledge of its derivative. Newton's method, a root finding algorithm, maximizes a function using knowledge of its second derivative. That can be faster when the second derivative is known and easy to compute (the Newton-Raphson algorithm is used in logistic regression). However, the analytic expression for the second derivative is often complicated or intractable, requiring a lot of computation. Numerical methods for computing the second derivative also require a lot of computation -- if $N$ values are required to compute the first derivative, $N^2$ are required for the second derivative.


Question: The process of sleep seems to be very disadvantageous to an organism as it is extremely vulnerable to predation for several hours at a time. Why is sleep necessary in so many animals? What advantage did it give the individuals that evolved to have it as an adaptation? When and how did it likely occur in the evolutionary path of animals?

This good non-scholarly article covers some of the usual advantages (rest/regeneration).
One of the research papers they mentioned (they linked to press release) was Conservation of Sleep: Insights from Non-Mammalian Model Systems by John E. Zimmerman, Ph.D.; Trends Neurosci. 2008 July; 31(7): 371–376. Published online 2008 June 5. doi:  10.1016/j.tins.2008.05.001; NIHMSID: NIHMS230885. To quote from the press release:

Because the time of lethargus coincides with a time in the round worms’ life cycle when synaptic changes occur in the nervous system, they propose that sleep is a state required for nervous system plasticity. In other words, in order for the nervous system to grow and change, there must be down time of active behavior. Other researchers at Penn have shown that, in mammals, synaptic changes occur during sleep and that deprivation of sleep results in a disruption of these synaptic changes.


Question:
I'll try to make this as brief as possible:
Dissolved two teaspoons of table sugar (sucrose) in about 250ml water. Sipped it, and as expected it tasted sweet. I let the rest of it sit in the freezer overnight. Next day, I took out the frozen sugar solution and, well, licked it.
Surprisingly, I could barely taste any sugar in it. It was almost as though I was licking regular ice.
Why is it that I'm not able to perceive any sweetness here?
I was under the impression that since the solution, being a homogeneous mixture of sugar and water, was sweet, the "popsicle" I made ought to taste sweet too (since the sugar would be evenly distributed over the volume of the ice).

Where is the sugar?
When you freeze a dilute aqueous sugar solution pure water freezes first, leaving a more concentrated solution until you reach a high concentration of sugar called the eutectic concentration.  Now you have the pure water that's frozen out, called proeutectic water, and the concentrated eutectic sugar solution from which the sugar is finally ready to freeze along with the water.  Upon freezing this eutectic composition forms a two-phase eutectic mixture, in which the sugar may appear as veins or lamellae (like veins of some ores among Earth's rocks, though these typically form form a different process).  If that structure is in the interior of the ice cube, likely since you cooled the solution from the outside, then licking the outside you got only the pure water proeutectic component.
See  for more about this process.
Addendum:  I tried this with store-bought fruit juice which was red in color.  Poured it into an ice tray and froze it overnight in my household freezer.  It appeared to be a homogeneous red mass and tasted sweet, but was also mushy implying some liquid was still present (after overnight freezing for an ice cube sized sample).  The juice was roughly 10% sugar by weight.


Question:
Here is the article that motivated this question: Does impatience make us fat?
I liked this article, and it nicely demonstrates the concept of “controlling for other variables” (IQ, career, income, age, etc) in order to best isolate the true relationship between just the 2 variables in question.
Can you explain to me how you actually control for variables on a typical data set?
E.g., if you have 2 people with the same impatience level and BMI, but different incomes, how do you treat these data?  Do you categorize them into different subgroups that do have similar income, patience, and BMI?  But, eventually there are dozens of variables to control for (IQ, career, income, age, etc)  How do you then aggregate these (potentially) 100’s of subgroups?  In fact, I have a feeling this approach is barking up the wrong tree, now that I’ve verbalized it.
Thanks for shedding any light on something I've meant to get to the bottom of for a few years now...!

There are many ways to control for variables.
The easiest, and one you came up with, is to stratify your data so you have sub-groups with similar characteristics - there are then methods to pool those results together to get a single "answer". This works if you have a very small number of variables you want to control for, but as you've rightly discovered, this rapidly falls apart as you split your data into smaller and smaller chunks.
A more common approach is to include the variables you want to control for in a regression model. For example, if you have a regression model that can be conceptually described as:
BMI = Impatience + Race + Gender + Socioeconomic Status + IQ

The estimate you will get for Impatience will be the effect of Impatience within levels of the other covariates - regression allows you to essentially smooth over places where you don't have much data (the problem with the stratification approach), though this should be done with caution.
There are yet more sophisticated ways of controlling for other variables, but odds are when someone says "controlled for other variables", they mean they were included in a regression model.
Alright, you've asked for an example you can work on, to see how this goes. I'll walk you through it step by step. All you need is a copy of R installed.
First, we need some data. Cut and paste the following chunks of code into R. Keep in mind this is a contrived example I made up on the spot, but it shows the process.
covariate <- sample(0:1, 100, replace=TRUE)
exposure  <- runif(100,0,1)+(0.3*covariate)
outcome   <- 2.0+(0.5*exposure)+(0.25*covariate)

That's your data. Note that we already know the relationship between the outcome, the exposure, and the covariate - that's the point of many simulation studies (of which this is an extremely basic example. You start with a structure you know, and you make sure your method can get you the right answer.
Now then, onto the regression model. Type the following:
lm(outcome~exposure)

Did you get an Intercept = 2.0 and an exposure = 0.6766? Or something close to it, given there will be some random variation in the data? Good - this answer is wrong. We know it's wrong. Why is it wrong? We have failed to control for a variable that effects the outcome and the exposure. It's a binary variable, make it anything you please - gender, smoker/non-smoker, etc.
Now run this model:
lm(outcome~exposure+covariate)

This time you should get coefficients of Intercept = 2.00, exposure = 0.50 and a covariate of 0.25. This, as we know, is the right answer. You've controlled for other variables.
Now, what happens when we don't know if we've taken care of all of the variables that we need to (we never really do)? This is called residual confounding, and its a concern in most observational studies - that we have controlled imperfectly, and our answer, while close to right, isn't exact. Does that help more?


Question:
Knapsack problems are easily solved by dynamic programming. Dynamic programming runs in polynomial time; that is why we do it, right?
I have read it is actually an NP-complete problem, though, which would mean that solving the problem in polynomial problem is probably impossible.
Where is my mistake?

Knapsack problem is $\sf{NP\text{-}complete}$ when the numbers are given as binary numbers. In this case, the dynamic programming will take exponentially many steps (in the size of the input, i.e. the number of bits in the input) to finish $\dagger$.
On the other hand, if the numbers in the input are given in unary, the dynamic programming will work in polynomial time (in the size of the input).
This kind of problems is called weakly $\sf{NP\text{-}complete}$.
$\dagger$: Another good example to understand the importance of the encoding used to give the input is considering the usual algorithms to see if a number is prime that go from $2$ up to $\sqrt{n}$ and check if any of them divide $n$. This is polynomial in $n$ but not necessarily in the input size. If $n$ is given in binary, the size of input is $\lg n$ and the algorithm runs in time $O(\sqrt{n}) = O(2^{\lg n/2})$ which is exponential in the input size. And the usual computational complexity of a problem is w.r.t. the size of the input.
This kind of algorithm, i.e. polynomial in the largest number that is part of the input, but exponential in the input length is called pseudo-polynomial.


Question:
In Hamming's book, The Art of Doing Science and Engineering, he relates the following story:

A group at Naval Postgraduate School was modulating a very high
  frequency signal down to where they could afford to sample, according
  to the sampling theorem as they understood it.  But I realized if they
  cleverly sampled the high frequency then the sampling act itself would
  modulate (alias) it down.  After some days of argument, they removed
  the rack of frequency lowering equipment, and the rest of the
  equipment ran better!

Are there any other ways to use aliasing as a primary technique for processing a signal, as opposed to a side-effect to be avoided?

The quoted text in the question is a case of using bandpass sampling or undersampling.
Here, to avoid aliasing distortion, the signal of interest must be bandpass. That means that the signal's power spectrum is only non-zero between $f_L < |f| < f_H$.
If we sample the signal at a rate $f_s$, then the condition that the subsequent repeated spectra do not overlap means we can avoid aliasing. The repeated spectra happen at every integer multiple of $f_s$.
Mathematically, we can write this condition for avoiding aliasing distortion as
$$\frac{2 f_H}{n} \le f_s \le \frac{2 f_L}{n - 1}$$
where $n$ is an integer that satisfies
$$1 \le n \le \frac{f_H}{f_H - f_L}$$
There are a number of valid frequency ranges you can do this with, as illustrated by the diagram below (taken from the wikipedia link above).

In the above diagram, if the problem lies in the grey areas, then we can avoid aliasing distortion with bandpass sampling --- even though the sampled signal is aliased, we have not distorted the shape of the signal's spectrum.


Question:
EDIT: I've now asked a similar question about the difference between categories and sets.
Every time I read about type theory (which admittedly is rather informal), I can't really understand how it differs from set theory, concretely.
I understand that there is a conceptual difference between saying "x belongs to a set X" and "x is of type X", because intuitively, a set is just a collection of objects, while a type has certain "properties". Nevertheless, sets are often defined according to properties as well, and if they are, then I am having trouble understanding how this distinction matters in any way.
So in the most concrete way possible, what exactly does it imply about $x$ to say that it is of type $T$, compared to saying that it is an element in the set $S$?
(You may pick any type and set that makes the comparison most clarifying).

To understand the difference between sets and types, ones has to go back to pre-mathematical ideas of "collection" and "construction", and see how sets and types mathematize these.
There is a spectrum of possibilities on what mathematics is about. Two of these are:

We think of mathematics as an activity in which mathematical objects are constructed according to some rules (think of geometry as the activity of constructing points, lines and circles with a ruler and a compass).
Thus mathematical objects are organized according to how they are constructed, and there are different types of construction. A mathematical object is always constructed in some unique way, which determines its unique type.

We think of mathematics as a vast universe full of pre-existing mathematical objects (think of the geometric plane as given). We discover, analyze and think about these objects (we observe that there are points, lines and circles in the plane). We collect them into set. Usually we collect elements that have something in common (for instance, all lines passing through a given point), but in principle a set may hold together an arbitrary selection of objects. A set is specified by its elements, and only by its elements. A mathematical object may belong to many sets.

We are not saying that the above possibilities are the only two, or that any one of them completely describes what mathematics is. Nevertheless, each view can serve as a useful starting point for a general mathematical theory that usefully describes a wide range of mathematical activities.
It is natural to take a type $T$ and imagine the collection of all things that we can construct using the rules of $T$. This is the extension of $T$, and it is not $T$ itself. For instance, here are two types that have different rules of construction, but they have the same extension:

The type of pairs $(n, p)$ where $n$ is constructed as a natural number, and $p$ is constructed as a proof demonstrating that $n$ is an even prime number larger than $3$.

The type of pairs $(m, q)$ where $m$ is constructed as a natural number, and $q$ is constructed as a proof demonstrating that $m$ is an odd prime smaller than $2$.

Yes, these are silly trivial examples, but the point stands: both types have nothing in their extension, but they have different rules of construction. In contrast, the sets
$$\{ n \in \mathbb{N} \mid \text{$n$ is an even prime larger than $3$} \}$$
and
$$\{ m \in \mathbb{N} \mid \text{$m$ is an odd prime smaller than $2$} \}$$
are equal because they have the same elements.
Note that type theory is not about syntax. It is a mathematical theory of constructions, just like set theory is a mathematical theory of collections. It just so happens that the usual presentations of type theory emphasize syntax, and consequently people end up thinking type theory is syntax. This is not the case. To confuse a mathematical object (construction) with a syntactic expression that represents it (a term former) is a basic category mistake that has puzzled logicians for a long time, but not anymore.


Question:
I'm a bit confused about the concept of ground, and perhaps voltage as well, particularly when trying to analyze a circuit. When I learned about Ohm's law in grade school, I learned how to apply the law to calculate current, voltage, and resistance of simple circuits.
For instance, if we were given the following circuit:

We would be could be asked to calculate the current passing through the circuit. At the time, I'd simply compute (based on the rules given) 1.5V/1Ohms=1.5A.
Later on, however, I learned that the reason the voltage of the resistor would be 1.5V is because voltage is really the difference in potential between two points, and that the difference of the voltage across the battery would be the same as that of the resistor (correct me if I'm mistaken), or 1.5V. I got confused, however, after the introduction of the concept of ground.
The first time I tried to do the current calculation for a circuit similar to the previous circuit on a simulator, the program complained about not having a ground and "floating voltage sources". After a bit of searching, I learned that circuits need ground as a reference point or for safety reasons. It was mentioned in one explanation that one can pick any node for ground, although it's customary to design circuits so there is a "easy place" to pick ground.
Thus for this circuit

I picked ground at the bottom, but would it be okay to pick ground between the 7 ohm and 2 ohm resistor - or any other place? And what would be the difference when analyzing the circuit?
I've read that there are 3 typical ground symbols with different meanings - chassis ground, earth ground, and signal ground. A lot of circuits I've seen used in exercises either use earth ground or signal ground. What purpose is there in using earth ground? What is the signal ground connected to?
Another question: since the ground is at unknown potential, wouldn't there be current flowing to or from ground to the circuit? From what I've read we treat the ground as 0V, but wouldn't there be some sort of effect because of a difference in potential of the circuit and ground? Would the effect be different depending on what ground was used?
Finally: In nodal analysis, one customarily picks a ground at the negative terminal of the battery. However, when there are multiple voltage sources, some of them are "floating". What meaning does the voltage of a floating voltage source have?

The first time I tried to do the current calculation for a circuit similar to the previous circuit on a simulator, the program complained about not having a ground and "floating voltage sources".

Your simulator wants to be able to do its calculations and report out the voltages of each node relative to some reference, rather than have to report the difference between every possible pair of nodes. It needs you to tell it which node is the reference node.
Other than that, for a well-designed circuit, the "ground" has no significance in the simulation. If you design a circuit where there is no dc path between two nodes, though, the circuit will be unsolvable. Typical SPICE-like simulators resolve this by connecting extra resistors, typically 1 GOhm, between every node and ground, so it is conceivable that the choice of ground node could artificially affect the results of a simulation of a very high-impedance circuit.

I picked ground at the bottom, but would it be okay to pick ground between the 7 ohm and 2 ohm resistor - or any other place? And what would be the difference when analyzing the circuit?

You can pick any node as your reference ground. Often we think ahead and pick a node that will eliminate terms for the equations (by setting them equal to 0), or simplify the schematic (by allowing us to indicate connections through a ground symbol instead of by a bunch of lines connecting together).

I've read that there are 3 typical ground symbols with different meanings - chassis ground, earth ground, and signal ground. A lot of circuits I've seen used in exercises use earth ground or signal ground. What purpose is there in using earth ground? What is the signal ground connected to?

Earth ground is used to indicate a connection to something that is physically connected to the ground beneath our feet. A wire leading through the building down to a copper rod driven into the ground, in a typical case. This ground is used for safety purposes. We assume that someone who handles our equipment will be connected to something like earth ground by their feet. So earth ground is the safest circuit node for them to touch, because it won't drive currents through their body.
Chassis ground is just the potential of the case or enclosure of your circuit. For safety purposes it's often best for this to be connected to earth ground. But calling it "chassis" instead of "earth" means you haven't assumed that it is connected.
Signal ground is often distinguished from earth ground (and partially isolated from it) to minimize the possibility that currents flowing through the earth ground wires will disturb measurements of the important signals.

Another question: since the ground is at unknown potential, wouldn't there be current flowing to or from ground to the circuit?

Remember, a complete circuit is required for current to flow. You would need connections to earth ground in two places for current to flow in and out of your circuit from earth ground. Realistically, you'd also need some kind of voltage source (a battery, or an antenna, or something) in one of those connection paths to have any sustained flow back and forth between your circuit and the earth.

However, when there are multiple voltage sources, some of them are "floating". What meaning does the voltage of a floating voltage source have?

If I have voltage source with value V between nodes a and b, it means that the voltage difference between a and b will be V volts. A perfect voltage source will generate whatever current is required to make this happen. If one of the nodes happens to be ground, that gives you immediately the value at the other node in your reference system. If neither of those nodes happens to be "ground" then you will need some other connections to establish the value of the voltages at a and b relative to ground.


Question:
I was coding a physics simulation, and noticed that I was using discrete time. That is, there was an update mechanism advancing the simulation for a fixed amount of time repeatedly, emulating a changing system.
I though that was interesting, and now believe the real world must behave just like my program does. It is actually advancing forward in tiny but discrete time intervals?

As we cannot resolve arbitrarily small time intervals, what is ''really'' the case cannot be decided.
But in classical and quantum mechanics (i.e., in most of physics), time is treated as continuous.
Physics would become very awkward if expressed in terms of a discrete time:
The discrete case is essentially untractable since analysis (the tool created by Newton, in a sense the father of modern physics) can no longer be applied.
Edit: If time appears discrete (or continuous) at some level, it could still be continuous (or discrete) at higher resolution. This is due to general reasons that have nothing to do with time per se. I explain it by analogy: For example, line spectra look discrete, but upon higher resolution one sees that they have a line width with a physical meaning.
Thus one cannot definitely resolve the question with finitely many observations of finite accuracy, no matter how contrived the experiment.


Question: Is there any general guidelines on where to place dropout layers in a neural network?

In the original paper that proposed dropout layers, by Hinton (2012), dropout (with p=0.5) was used on each of the fully connected (dense) layers before the output; it was not used on the convolutional layers. This became the most commonly used configuration.
More recent research has shown some value in applying dropout also to  convolutional layers, although at much lower levels: p=0.1 or 0.2. Dropout was used after the activation function of each convolutional layer: CONV->RELU->DROP.


Question: What are some recommended resources (books, tutorials, lectures, etc.) on digital signal processing, and how to begin working with it on a technical level?

My recommendation in terms of text books is Rick Lyons's Understanding DSP.  My review of the latest edition is here.
I, and many others from the ${\tt comp.dsp}$ community and elsewhere, have helped Rick revise parts of the text since the first edition.
For self-study, I know of no better book.
As an on-line, free resource, I recommend Steve Smith's book.  Personally, I prefer Rick's style, but Steve's book as the advantage of online accessibility (and the online version is free!).

Edit:
Rick sent me some feedback that I thought I'd share here:
For your colleagues that have a copy of my DSP book,
I'll be happy to send them the errata for my book.  All they have
to do is send me an E-mail telling me (1) The Edition Number,
and (2) the Printing Number of their copy of the book.  The Printing
Number can be found on the page just before the 'Dedication' page.
My E-mail address is:
R.Lyons [at] ieee.org
I recommend that your colleagues have a look at:

Rick also gave me a long list of online DSP references.  There are way too many to put here. I will see about setting up a GoogleDocs version and re-post here later.


Question:
It is my understanding that metals are a crystal lattice of ions, held together by delocalized electrons, which move freely through the lattice (and conduct electricity, heat, etc.).
If two pieces of the same metal are touched together, why don't they bond?
It seems to me the delocalized electrons would move from one metal to the other, and extend the bond, holding the two pieces together. If the electrons don't move freely from one piece to the other, why would this not happen when a current is applied (through the two pieces)?

I think that mere touching does not bring the surfaces close enough. The surface of a metal is not perfect usually. Maybe it has an oxide layer that resists any kind of reaction. If the metal is extremely pure and if you bring two pieces of it extremely close together, then they will join together. It's also called cold welding.
For more information:

What prevents two pieces of metal from bonding?
Cold Welding


Question:
I am working with over a million (long) reads, and aligning them to a large genome. I am considering running my alignment jobs in parallel, distributing horizontally across hundreds of nodes rather than trying to run a single job with dozens of cores.
I would like to merge the sorted BAM files together for further downstream analysis. What is the most efficient way to do so while maintaining a valid file header and taking advantage of the fact that the input bam files are already sorted?

samtools merge merged.bam *.bam is efficient enough since the input files are sorted. You can get a bit faster with sambamba and/or biobambam, but they're not typically already installed and IO quickly becomes a bottleneck anyway.


Question:
First off, I hope this is the correct Stack Exchange board. My apologies if it is not.
I am working on something that requires me to calibrate the camera. I have successfully implemented the code to do this in OpenCV (C++). I am using the inbuilt chessboard functions and a chessboard I have printed off.
There are many tutorials on the internet which state to give more than one view of the chessboard and extract the corners from each frame.
Is there an optimum set of views to give to the function to get the most accurate camera calibration? What affects the accuracy of the calibration?
For instance, if I give it 5 images of the same view without moving anything it gives some straight results when I try and undistort the webcam feed.
FYI to anyone visiting: I've recently found out you can get must better camera calibration by using a grid of asymmetric circles and the respective OpenCV function.

You have to take images for calibration from different points of view and angles, with as big difference between angles as possible (all three Euler angles should vary), but so that pattern diameter was still fitting to camera field of view. The more views are you using the better calibration will be. That is needed because during the calibration you detect focal length and  distortion parameters, so to get them by least square method different angles are needed. If you arn't moving camera at all you are not getting new information and calibration is useless.
Be aware, that you usually need only focal length, distortion parameters are usually negligible even for consumer cameras, web cameras and cell phone cameras. If you already know focal length from the camera specification you may not even need calibration.
Distortion coefficient are more present in "special" cameras like wide-angle or 360°.
Here is the Wikipedia entry about calibration.
And here is non-linear distortion, which is negligible for most cameras.


Question:
In a multicore processor, what happens to the contents of a core's cache (say L1) when a context switch occurs on that cache?
Is the behaviour dependent on the architecture or is it a general behaviour followed by all chip manufacturers?

That depends both on the processor (not just the processor series, it can vary from model to model) and the operating systems, but there are general principles. Whether a processor is multicore has no direct impact on this aspect; the same process could be executing on multiple cores simultaneously (if it's multithreaded), and memory can be shared between processes, so cache synchronization is unavoidable regardless of what happens on a context switch.
When a processor looks up a memory location in the cache, if there is an MMU, it can use either the physical or the virtual address of that location (sometimes even a combination of both, but that's not really relevant here).
With physical addresses, it doesn't matter which process is accessing the address, the contents can be shared. So there is no need to invalidate the cache content during a context switch. If the two processes map the same physical page with different attributes, this is handled by the MMU (acting as a MPU (memory protection unit)). The downside of a physically addressed cache is that the MMU has to sit between the processor and the cache, so the cache lookup is slow. L1 caches are almost never physically addresses; higher-level caches may be.
The same virtual address can denote different memory locations in different processes. Hence, with a virtually addressed cache, the processor and the operating system must cooperate to ensure that a process will find the right memory. There are several common techniques. The context-switching code provided by the operating system can invalidate the whole cache; this is correct but very costly. Some CPU architectures have room in their cache line for an ASID (address space identifier) the hardware version of a process ID, also used by the MMU. This effectively separates cache entries from different processes, and means that two processes that map the same page will have incoherent views of the same physical page (there is usually a special ASID value indicating a shared page, but these need to be flushed if they are not mapped to the same address in all processes where they are mapped). If the operating system takes care that different processes use non-overlapping address spaces (which defeats some of the purpose of using virtual memory, but can be done sometimes), then cache lines remain valid.
Most processors that have an MMU also have a TLB. The TLB is a cache of mappings from virtual addresses to physical addresses. The TLB is consulted before lookups in physically-addressed caches, to determine the physical address quickly when possible; the processor may start the cache lookup before the TLB lookup is complete, as often candidate cache lines can be identified from the middle bits of the address, between the bits that determine the offset in a cache line and the bits that determine the page. Virtually-addressed caches bypass the TLB if there is a cache hit, although the processor may initiate the TLB lookup while it is querying the cache, in case of a miss.
The TLB itself must be managed during a context switch. If the TLB entries contain an ASID, they can remain in place; the operating system only needs to flush TLB entries if their ASID has changed meaning (e.g. because a process has exited). If the TLB entries are global, they must be invalidated when switching to a different context.


Question:
We were dealing with the Third Law of Thermodynamics in class, and my teacher mentioned  something that we found quite fascinating:

It is physically impossible to attain a temperature of zero kelvin (absolute zero).

When we pressed him for the rationale behind that, he asked us to take a look at the graph for Charles' Law for gases:

His argument is, that when we extrapolate the graph to -273.15 degrees Celsius (i.e. zero kelvin), the volume drops down all the way to zero; and "since no piece of matter can occupy zero volume ('matter' being something that has mass and occupies space), from the graph for Charles' Law, it is very clear that it is not possible to attain the temperature of zero kelvin".
However, someone else gave me a different explanation: "To reduce the temperature of a body down to zero kelvin, would mean removing all the energy associated with the body. Now, since energy is always associated with mass, if all the energy is removed there won't be any mass left. Hence it isn't possible to attain absolute zero."
Who, if anybody, is correct?

Edit 1: A note-worthy point made by @Loong a while back:

(From the engineer's perspective) To cool something to zero kelvin, first you'll need something that is cooler than zero kelvin.

Edit 2: I've got an issue with the 'no molecular motion' notion that I seem to find everywhere (including @Ivan's fantastic answer) but I can't seem to get cleared.
The notion:

At absolute zero, all molecular motion stops. There's no longer any kinetic energy asscoiated with molecules/atoms.

The problem? I quote Feynman:

As we decrease the temperature, the vibration decreases and decreases until, at absolute zero, there is a minimum amount of motion that atoms can have, but not zero.

He goes on to justify this by bringing in Heisenberg's Uncertainity Principle:

Remember that when a crystal is cooled to absolute zero, the atoms do not stop moving, they still 'jiggle'. Why? If they stopped moving, we would know were they were and that they had they have zero motion, and that is against the Uncertainity Principle. We cannot know where they are and how fast they are moving, so they must be continually wiggling in there!

So, can anyone account for Feynman's claim as well? To the not-so-hardcore student of physics that I am (high-schooler here), his argument seems quite convincing.
So to make it clear; I'm asking for two things in this question:
1) Which argument is correct? My teacher's or the other guy's?
2) At absolute zero, do we have zero molecular motion as most sources state, or do atoms go on "wiggling" in there as Feynman claims?

There was a story in my days about a physical chemist who was asked to explain some effect, illustrated by a poster on the wall. He did that, after which someone noticed that the poster was hanging upside down, so the effect appeared reversed in sign. Undaunted, the guy immediately explained it the other way around, just as convincingly as he did the first time.
Cooking up explanations on the spot is a respectable sport, but your teacher went a bit too far. What's with that Charles' law? See, it is a gas law; it is about gases. And even then it is but an approximation. To make it exact, you have to make your gas ideal, which can't be done. As you lower the temperature, all gases become less and less ideal. And then they condense, and we're left to deal with liquids and solids, to which the said law never applied, not even as a very poor approximation. Appealing to this law when we are near the absolute zero is about as sensible as ruling out certain reaction mechanism on the grounds that it requires atoms to move faster than allowed by the road speed limit in the state of Hawaii.
The energy argument is even more ridiculous. We don't have to remove all energy, but only the kinetic energy. The $E=mc^2$ part remains there, so the mass is never going anywhere.
All that being said, there is no physical law forbidding the existence of matter at absolute zero. It's not like its existence will cause the world to go down with error 500. It's just that the closer you get to it, the more effort it takes, like with other ideal things (ideal vacuum, ideally pure compound, crystal without defects, etc). If anything, we're doing a pretty decent job at it. Using sophisticated techniques like laser cooling or magnetic evaporative cooling, we've long surpassed the nature's record in coldness.


Question:
I'm looking for tools to check the quality of a VCF I have of a human genome. I would like to check the VCF against publicly known variants across other human genomes, e.g. how many SNPs are already in public databases, whether insertions/deletions are at known positions, insertion/deletion length distribution, other SNVs/SVs, etc.? I suspect that there are resources from previous projects to check for known SNPs and InDels by human subpopulations.
What resources exist for this, and how do I do it?

To achieve (at least some of) your goals, I would recommend the Variant Effect Predictor (VEP). It is a flexible tool that provides several types of annotations on an input .vcf file.  I agree that ExAC is the de facto gold standard catalog for human genetic variation in coding regions.  To see the frequency distribution of variants by global subpopulation make sure "ExAC allele frequencies" is checked in addition to the 1000 genomes.
Output in the web-browser:

If you download the annotated .vcf, frequencies will be in the INFO field:
##INFO=<ID=CSQ,Number=.,Type=String,Description="Consequence annotations from Ensembl VEP. Format: Allele|Consequence|IMPACT|SYMBOL|Gene|Feature_type|Feature|BIOTYPE|EXON|INTRON|HGVSc|HGVSp|cDNA_position|CDS_position|Protein_position|Amino_acids|Codons|Existing_variation|DISTANCE|STRAND|FLAGS|SYMBOL_SOURCE|HGNC_ID|TSL|SIFT|PolyPhen|AF|AFR_AF|AMR_AF|EAS_AF|EUR_AF|SAS_AF|AA_AF|EA_AF|ExAC_AF|ExAC_Adj_AF|ExAC_AFR_AF|ExAC_AMR_AF|ExAC_EAS_AF|ExAC_FIN_AF|ExAC_NFE_AF|ExAC_OTH_AF|ExAC_SAS_AF|CLIN_SIG|SOMATIC|PHENO|MOTIF_NAME|MOTIF_POS|HIGH_INF_POS|MOTIF_SCORE_CHANGE

The previously mentioned Annovar can also annotate with ExAC allele frequencies.  Finally, should mention the newest whole-genome resource, gnomAD.


Question: I have a dataset that has both continuous and categorical data. I am analyzing by using PCA and am wondering if it is fine to include the categorical variables as a part of the analysis. My understanding is that PCA can only be applied to continuous variables. Is that correct? If it cannot be used for categorical data, what alternatives exist for their analysis?

Although a PCA applied on binary data would yield results comparable to those obtained from a Multiple Correspondence Analysis (factor scores and eigenvalues are linearly related), there are more appropriate techniques to deal with mixed data types, namely Multiple Factor Analysis for mixed data available in the FactoMineR R package (FAMD()). If your variables can be considered as structured subsets of descriptive attributes, then Multiple Factor Analysis (MFA()) is also an option.
The challenge with categorical variables is to find a suitable way to represent distances between variable categories and individuals in the factorial space. To overcome this problem, you can look for a non-linear transformation of each variable--whether it be nominal, ordinal, polynomial, or numerical--with optimal scaling. This is well explained in Gifi Methods for Optimal Scaling in R: The Package homals, and an implementation is available in the corresponding R package homals.


Question:
I'm considering learning a new language to use for numerical/simulation modelling projects, as a (partial) replacement for the C++ and Python that I currently use. I came across Julia, which sounds kind of perfect. If it does everything it claims, I could use it to replace both C++ and Python in all my projects, since it can access high-level scientific computing library code (including PyPlot) as well as running for loops at a similar speed to C. I would also benefit from things like proper coroutines that don't exist in either of the other languages.
However, it's a relatively new project, currently at version 0.x, and I found various warnings (posted at various dates in the past) that it's not quite ready for the day to day use. Consequently, I would like some information about the status of the project right now (February 2014, or whenever an answer is posted), in order to help me assess whether I personally should consider investing the time to learn this language at this stage.
I would appreciate answers that focus on specific relevant facts about the Julia project; I'm less interested in opinions based on experience with other projects.
In particular, a comment by Geoff Oxberry suggests that the Julia API is still in a state of flux, requiring the code to be updated when it changes. I would like to get an idea of the extent to which this is the case: which areas of the API are stable, and which are likely to change?
I guess typically I would mostly be doing linear algebra (e.g. solving eigenproblems), numerical integration of ODEs with many variables, and plotting using PyPlot and/or OpenGL, as well as low-level C-style number crunching (e.g. for Monte Carlo simulations). Is Julia's library system fully developed in these areas? In particular, is the API more or less stable for those types of activities, or would I find that my old code would tend to break after upgrading to a new version of Julia?
Finally, are there any other issues that would be worth considering in deciding whether to use Julia for serious work at the present time?

Julia, at this point (May 2019, Julia v1.1 with v1.2 about to come out) is quite mature for scientific computing. The v1.0 release signified an end to yearly code breakage. With that, a lot of scientific computing libraries have had the time to simply grow without disruption. A broad overview of Julia packages can be found at pkg.julialang.org.
For core scientific computing, the DifferentialEquations.jl library for differential equations (ODEs, SDEs, DAEs, DDEs, Gillespie simulations, etc.), Flux.jl for neural networks, and the JuMP library for mathematical programming (optimization: linear, quadratic, mixed integer, etc. programming) are three of the cornerstones of the scientific computing ecosystem. The differential equation library in particular is far more developed than what you'd see in other languages, with a large development team implementing features like EPIRK integrators, Runge-Kutta-Nystrom, Stiff/Differential-Algebraic delay differential equation, and adaptive time stiff stochastic differential equation integrators, along with a bunch of other goodies like adjoint sensitivity analysis, chemical reaction DSLs, matrix-free Newton-Krylov, and full (data transfer free) GPU compatibility, with training of neural differential equations, all with fantastic benchmark results (disclaimer: I am the lead developer).
The thing that is a little mind-boggling about the matured Julia ecosystem is its composibility. Essentially, when someone builds a generic library function like those in DifferentialEquations.jl, you can use any AbstractArray/Number type to generate new code on the fly. So for example, there is a library for error propagation (Measurements.jl) and when you stick it in the ODE solver, it automatically compiles a new version of the ODE solver which does error propagation without parameter sampling. Because of this, you may not find some features documented because the code for the features generates itself, and so you need to think more about library composition.
One of the ways where composition is most useful is in linear algebra. The ODE solvers for example allow you to specify jac_prototype, letting you give it the type for the Jacobian that will be used internally. Of course there's things in the LineraAlgebra standard library like Symmetric and Tridiagonal you can use here, but given the utility of composibility in type generic algorithms, people have by now gone and built entire array type libraries. BandedMatrices.jl and BlockBandedMatrices.jl are libraries which define (Block) banded matrix types which have fast lu overloads, making them a nice way to accelerate the solution of stiff MOL discretizations of systems of partial differential equations. PDMats.jl allows for the specification of positive-definite matrices. Elemental.jl allows you to define a distributed sparse Jacobian. CuArrays.jl defines arrays on the GPU. Etc.
Then you have all of your number types. Unitful.jl does unit checking at compile time so it's an overhead-free units library. DoubleFloats.jl is a fast higher precision library, along with Quadmath.jl and ArbFloats.jl. ForwardDiff.jl is a library for forward-mode automatic differentiation which uses Dual number arithmetic. And I can keep going listing these out. And yes, you can throw them into sufficiently generic Julia libraries like DifferentialEquations.jl to compile a version specifically optimized for these number types. Even something like ApproxFun.jl which is functions as algebraic objects (like Chebfun) works with this generic system, allowing the specification of PDEs as ODEs on scalars in a function space.
Given the advantages of composibility and the way that types can be use to generate new and efficient code on generic Julia functions, there has been a lot of work to get implementations of core scientific computing functionality into pure Julia. Optim.jl for nonlinear optimization, NLsolve.jl for solving nonlinear systems, IterativeSolvers.jl for iterative solvers of linear systems and eigensystems, BlackBoxOptim.jl for black-box optimization, etc. Even the neural network library Flux.jl just uses CuArrays.jl's automatic compilation of code to the GPU for its GPU capabilities. This composibility was the core of what created things like neural differential equations in DiffEqFlux.jl. Probabilistic programming languages like Turing.jl are also quite mature now and make use of the same underlying tooling.
Since Julia's libraries are so fundamentally based on code generation tools, it should be no surprised that there's a lot of tooling around code generation. Julia's broadcast system generates fused kernels on the fly which are overloaded by array types to give a lot of the features mentioned above. CUDAnative.jl allows for compiling Julia code to GPU kernels. ModelingToolkit.jl automatically de-sugars ASTs into a symbolic system for transforming mathematical code. Cassette.jl lets you "overdub" someone else's existing function, using rules to change their function before compile time (for example: change all of their array allocations to static array allocations and move operations to the GPU). This is more advanced tooling (I don't expect everyone doing scientific computing to take direct control of the compiler), but this is how a lot of the next generation tooling is being built (or rather, how the features are writing themselves).
As for parallelism, I've mentioned GPUs, and Julia has built-in multithreading and distributed computing. Julia's multithreading will very soon use a parallel-tasks runtime (PARTR) architecture which allows for automated scheduling of nested multithreading. If you want to use MPI, you can just use MPI.jl. And then of course, the easiest way to make use of it all is to just use an AbstractArray type setup to use the parallelism in its operations.
Julia also has the basic underlying ecosystem you would expect of a general purpose language used for scientific applications. It has the Juno IDE with a built-in debugger with breakpoints, it has Plots.jl for making all sorts of plots. A lot of specific tools are nice as well, like Revise.jl automatically updates your functions/library when a file saves. You have your DataFrames.jl, statistics libraries, etc. One of the nicest libraries is actually Distributions.jl which lets you write algorithms generic to the distribution (for example: rand(dist) takes a random number of whatever distribution was passed in), and there's a whole load of univariate and multivariate distributions (and of course dispatch happens at compile time, making this all as fast as hardcoding a function specific to the distribution). There is a bunch of data handling tooling, web servers, etc. you name it. At this point it's mature enough that if there's a basic scientific thing and you'd expect for it to exist, you just Google it with .jl or Julia and it'll show up.
Then there's a few things to keep in mind on the horizon. PackageCompiler is looking to build binaries from Julia libraries, and it already has some successes but needs more development. Makie.jl is a whole library for GPU-accelerated plotting with interactivity, and it still needs some more work but it's really looking to become the main plotting library in Julia. Zygote.jl is a source-to-source automatic differentiation library which doesn't have the performance issues of a tracing-based AD (Flux's Tracker, PyTorch, Jax), and that is looking to work on all pure Julia codes. Etc.
In conclusion, you can find a lot of movement in a lot of places, but in most areas there is already a solid matured library. It's no longer at a place where you ask "will it be adopted?": Julia has been adopted by enough people (millions of downloads) that it has the momentum to stay around for good. It has a really nice community, so if you ever just want to shoot the breeze and talk about parallel computing or numerical differential equations, some of the best chat rooms for that are in the Julialang Slack. Whether it's a language you should learn is a personal question, and whether it's the right language for your project is a technical question, and those are different. But is it a language that has matured and has the backing of a large consistent group of developers? That seems to be an affirmative yes.


Question:
Software is a fundamental part of computational science, and is increasingly recognized as an essential part of the scientific record.  Given the value of using existing and well-tested code, it seems worthwhile to communicate the existence of useful codes as widely as possible and credit their creators.  In an academic setting, this means publishing some papers that are primarily focused on software.
Where can one publish scholarly works whose primary focus is computational software?  To be completely clear, I'm referring to works that may not include any new mathematics, algorithms, etc. -- they are really focused on software.
I would also be interested in hearing from those who have submitted such papers to these journals, what the experience was like and which venues they recommend.

Summary of answers given:

Transactions on Mathematical Software
Scientific Programming
SIAM Journal on Scientific Computing (SISC) Software section
The Archive of Numerical Software
Open Research Computation
Computer Physics Communications
Advances in Engineering Software
Journal of Statistical Software
Journal of Chemical Theory and Computation
Source Code for Biology and Medicine
PLoS ONE
International Journal of Quantum Chemistry
Epidemiology
Computing in Science & Engineering
Journal of Computational Chemistry
Geoscientific Model Development
Journal of Machine Learning Research
Mathematical Programming Computation
Journal of Open Source Software
SoftwareX

There are some other application-specific journals to list: such as Journal of Computational Physics or Computer Physics Communications, that accept articles both about algorithms as well as the software used to implement them. If you're in the chemistry field, Journal of Chemical Theory and Computation might be another journal to consider. All of these do allow packages to be published—I've seen codes I've used discussed in them. Computers and Chemical Engineering does allow software implementation papers, but they need to do something original—it can't be an "incremental advance" paper.