> It also opens the door to a “nightmare scenario”: That the two viruses will meet in a single person, swap their mutations, and create an even more dangerous strain of the SARS-CoV-2 virus.

How would that even work? This is an RNA virus: is there a meiosis-like mechanism for two different RNA viruses infecting the same cell to exchange genes?

Yes there is, see [1] for details. Either by reassortment or copy choice recombination if both virus variants infect the same cell.

[1]https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3324781/

I've been very happy with Binary Eye: https://f-droid.org/en/packages/de.markusfisch.android.binar...

Also not a chemist, but here's my basic understanding.

The tree absorbs CO2 from the atmosphere and combines it with water (H2O) from the soil to produce more complex chemical compounds (such as carbohydrates). This process uses sunlight as the source of energy, and is better known as photosynthesis. The chemical compounds thus produced are used by the tree as structural material (the wood), or as stored energy (basically, reverting the photosynthesis reaction, aka "burning", releases the energy).

If the tree matter gets consumed by animals, those animals are going to use the stored energy, and ultimately re-release the stored carbon as CO2. If the tree just dies and is allowed to decompose, bacteria and other microorganisms will do the same: they'll eat the carbohydrates that the tree produced, and they'll breathe out the resulting CO2. If the tree is burned as fuel, the CO2 gets re-emitted directly.

So, to truly remove that CO2 from the atmosphere, the tree needs to be felled once it's stopped growing, and the resulting wood stored someplace where it can't be decomposed by microorganisms. Burying it is one solution to this (and this is what happened during the carboniferous era, when much of our coal and oil got created: dead trees fell in shallow swamps and were quickly buried under a layer of silt which prevented the decomposition).

Again, I'm no expert, so I'm happy to stand corrected if I've made any mistakes above.

The easiest thing to do is to burn it into biochar and then either bury that or use it as a fertilizer on fields where it will get taken up in the soil.

There are some active land management techniques which do something similar with shrubs/plants/grasses which generate an enormous amount of soil and therefore trap a lot of carbon.

Interesting, I hadn't realized pyrolysis (used to produce biochar) does not release CO2. Seeing "pyro" (Greek for "fire") I had assumed oxidation. Sounds like a good technique for making the wood "indigestible" for microorganisms. I wonder if it's worth doing energywise, compared with just burying it somewhere.

Absorbing the photon would be a two-fer. Reflecting it is just starting the next two-fer. It's two-fers all the way down.

Ooh. Even better, it's like compound interest.

You emit photon 1. It has momentum m. It comes back blueshifted, so you get momentum km, with k > 1. You reflect that back, and you get momentum k^2m...

It's not that simple, because as you start to move away, you redshift the photons you reflect. And the alignment issues are going to be pretty severe. And if you get too much compound interest, the photons may be blue-shifted enough to kill you or damage your ship. Still, the idea is pretty slick.

Also in all slingshot maneuvers you get more the closer you are, so you wanna pour in the most energy the closest you can get.

Only commenting on the coding style: that kind of formatting is just looking for trouble. Quick, tell me which of the functions below contains a bug?

  //return = strlen(target)
  unsigned strmcat(char *target, const char *source, unsigned length) {
    const char *origin = target;
    while(*target && length) target++, length--;
    return (target - origin) + strmcpy(target, source, length);
  }

  //return = strlen(target)
  unsigned strmcat(char *target, const char *source, unsigned length) {
    const char *origin = target;
    while(*target && length) target++; length--;
    return (target - origin) + strmcpy(target, source, length);
  }

How about this?

  //return = strlen(target)
  unsigned strmcat(char *target, const char *source, unsigned length) {
    const char *origin = target;
    while(*target && length)
      target++, length--;
    return (target - origin) + strmcpy(target, source, length);
  }

  //return = strlen(target)
  unsigned strmcat(char *target, const char *source, unsigned length) {
    const char *origin = target;
    while(*target && length)
      target++;
    length--;
    return (target - origin) + strmcpy(target, source, length);
  }

Granted, it's a tiny example, but you're going to be writing fewer bugs in the long run if you avoid being clever. So here are two rules to start with:

1. Never put more than one statement on one line.

2. Never use the comma operator outside the "for" syntax.

Please record these sessions and upload them to YouTube, so they'll help more than just one person. Thanks for volunteering.

Thanks for the suggestion, and I share the sentiment, but I'm not going to do that. I'm happy for the student to record them and later upload them if (s)he wants to, but I don't want to commit to broadcasting because:

1) I'd rather not have the distraction of thinking "is this going on YouTube?" permeating the lesson and changing the student's (and my) responses. You'd be amazed how much harder it is to think when you suspect the entire internet may get to hear your answers.

2) Things that come up might not be interesting to other people; I take an extremely interactive approach, ideally with the student doing about half the talking.

3) Given the audience, it's possible people might want to ask me about how to apply some mathematics to their business. They may not want relevant information published.

That said, if at the end of the lessons it turns out that they might be a useful resource, and the student agrees, I'll be happy to do this.

Yes, I agree. Heck you could take popcorn.js and make a course out of it like one HN user did with his Django101.com idea. I am not available during those times on the weekday, otherwise I would certainly apply.

I'm not sure what you mean by "scaling". Just because it uses a media query to serve a different style based on the screen size doesn't mean it "scales well".

In particular, this reacts quite badly to zooming, either in a desktop browser (chrome/linux): http://imgur.com/r1z9W or in a mobile browser (android): http://imgur.com/7aP39 .

In the desktop case, the font size doesn't change even if I zoom in the entire page. This isn't the default behavior, so the author must have gone to some lengths to break this functionality. I'm sure s/he had reasons for doing that, but I'm not sure what they were.

In the mobile case, zooming is constrained to a very limited range, and even when allowed, the text doesn't reflow, so it's hard to read lines because of all of the horizontal scrolling required. This behavior is quite common for fixed width, "grid" layouts.

In general, I'm all for frameworks that solve common layout problems, but this particular framework seems to have gotten the basics wrong. I would recommend against using it as it stands.

Thanks for the explanation. I don't own a smartphone or have experience with media queries, so this was one of my first times seeing media queries in action and I'm easily impressed.

By "love the scaling", I guess I meant "I love media queries."

Agreed. The framework looks fantastic but that is definitely a deal breaker. Zooming in on the web to see text larger is such a huge use-case.

That's a really good analysis of the current limitations of this framework. I'm wondering whether you happened to send this criticism to Skeleton's creator to see if it's something he's aware of, or something that he intends to improve.

Looks like Dave Gamache pushed an update to address zooming.

https://twitter.com/#!/dhg/statuses/92687926823092224

1) Please, NEVER EVER assume you know how the fonts will look on the users device. The iPhone is not the only "mobile platform" out there, and it doesn't even have the majority. Different phones will have different fonts, different default font sizes, different screen sizes, etc. As such "user-scalable=no" will guarantee people all over the world will hate you, including iPhone users who have a different opinion than yourself on what the "right font size" is. Just saying: "I'm using bigger fonts than on the web" will probably push you in the other extreme, with fonts too large and users unable to scale them down.

In conclusion: ALWAYS use "user-scalable=yes". Like this you'll give the user the option of correcting your assumptions if they turn out to be wrong.

Thanks for the article otherwise.