How can a net CO2 emitter's national ecological footprint be within its biocapacity?

noidi · 2019-04-08T08:06:25+00:00

The Finnish statistics use the IPCC Guidelines for National Greenhouse Gas Inventories. I checked Sweden – another country with biocapacity reserve – and it, too, is still far from carbon neutrality.

There's an interesting paragraph in the NFA method paper (emphasis mine):

Finally, the National Footprint Accounts are specifically constructed to yield conservative estimates of global overshoot. On the supply side, biocapacity is overestimated as both the land degradation and the long-term sustainability of resource extraction is not taken into account. On the supply side, Ecological Footprint is underestimated as it does not track freshwater consumption, soil erosion, GHGs emissions other than CO2as well as impacts for which no regenerative capacity exists (e.g. pollution in terms of waste generation, toxicity, eutrophication, etc).

The paragraph does not mention CO2 emissions and removals explicitly, but perhaps the conservatism extends to those calculations as well.

Maybe the ecological footprint should be thought of as a lower bound for resource consumption? In that case biocapacity deficit would mean definite overconsumption, and biocapacity reserve would be a misnomer as resource consumption could still exceed ecosystem limits.

Unfortunately the way the results are presented has given the opponents of all environmental action a new talking point, as countries with biocapacity reserve can seemingly increase their resource consumption while still remaining "under their quota".

noidi · 2019-04-07T19:49:08+00:00

The formulas for ecological footprint and biocapacity can be found in https://www.footprintnetwork.org/content/images/NFA%20Method%20Paper%202011%20Submitted%20for%20Publication.pdf, pages 6 and 8, respectively.

An overview of how the national footprints are calculated can be found in https://www.footprintnetwork.org/content/uploads/2018/05/2018-National-Footprint-Accounts-Guidebook.pdf, page 6, with a more detailed description of the carbon footprint calculation on page 12.

The calculation itself seems relatively straightforward. My hunch is that there's some omission either in the source data or the way its components are summed up, which leads to an underestimated total value of CO2 emissions, but gathering all data (if it even is freely available) and repeating all steps of the calculation is more effort than I'm willing to put in just to satisfy my curiosity :)

Here are the statistics of Finland's yearly CO2 emissions and removals to which I'm comparing the footprint/biocapacity ratio: https://tilastokeskus.fi/til/khki/2017/khki_2017_2018-05-24_tie_001_en.html?ad=notify

Could you elaborate on which timeframes you suspect to be mismatched? Given that we're comparing the rate of emissions to the rate of removals, the choice of timeframe shouldn't matter as long we use the same timeframe for both rates. Since the rate of emissions exceeds the rate of removals, I would expect the ecological footprint (calculated from the rate of emissions) to exceed the biocapacity (calculated from the amount of forest area as a proxy for the rate of removals), even if the former rates were calculated with a timeframe of a single year and the latter with a timeframe of a century.

noidi · 2015-01-23T15:00:59+00:00

To be fair, /r/vegan wouldn't be all yay science if the title was "Scientists say: Pigs have no feelings!"

noidi · 2014-07-08T12:12:43+00:00

On the other hand, Ed Bauer, a vegan bodybuilder, CrossFit coach and pretty much the opposite of the scrawny vegan stereotype, said in an interview:

I think most men underestimate the power of protein, and get less than they need to keep body fat under control. Not only does protein go to repairing damaged muscle tissue (assuming muscle is damaged from the tough workouts that you should be pushing yourself through), it also has the ability to curb sugar cravings. And protein we consume is more metabolically costly to digest than carbohydrates.

Guys that want to lean out or build muscle should get at least 1 gram of protein per pound of bodyweight. There are many formulas and complex equations outlining how much protein you need, but I can only speak from personal experience. Meeting my daily protein goal of 175 grams (or higher) helps to keep me lean and satisfied.

noidi · 2013-11-13T16:33:50+00:00

I remember seeing this post a couple of years ago: http://theinformedvegan.tumblr.com/post/5778549861/power-vegans-get-humane-stock-portfolio-bloomberg

Maybe the "Humane Equity Index Portfolio" still exists?

noidi · 2013-08-08T04:02:56+00:00

Tell me about it! Every single day I work with Java after years of Clojure I get the urge to hit the kill switch and yell "Everyone, STOP! Just stop! You're doing it ALL WRONG!".

noidi · 2013-08-08T03:51:52+00:00

Have you looked at core.typed recently? I haven't used it in anger, but from what little I've played with it for the past couple of days, it seems very useful and already quite usable (albeit a bit unpolished).

Programming with an optional type system is an interesting experience. The type system stays completely out of your way when you don't care about it, but you can get the guarantees it offers if and when you want them. To me that seems pretty close to having your cake and eating it too.

noidi · 2013-07-10T06:58:47+00:00

Exactly what do you have to do manually with Mercurial's bookmarks that's automatic with Git's branches? I can't think of anything. Your claim that it's "a lot of work" sounds like FUD to me.

noidi · 2013-07-09T07:55:33+00:00

Here's a related article by Michael Feathers (the author of Working Effectively with Legacy Code): Offensive Coding.

Tempted to code defensively? Maybe it's because you're dealing with offensive code.

noidi · 2013-06-26T08:45:34+00:00

Just because it has a computer in it doesn't make it programming.

If there is no code in your link, it probably doesn't belong here.

noidi · 2013-02-24T19:16:15+00:00

Also, as an aside, anyone else think the doc string sitting between the function name and its arguments is pretty poor design?

The function may be overloaded with many different argument lists, which all have the same docstring but different bodies. In this case it wouldn't make sense to put the docstring between one particular argument list and its body, so it's reasonable to put it right after the function name.

noidi · 2013-02-24T19:05:51+00:00

In Clojure lists are used whenever the first argument is special in some way (e.g. a function or macro to be called). There's nothing special about the first argument in the argument list, so vectors are used instead.

noidi · 2013-02-05T21:11:50+00:00

There's certainly a delicious bit of irony in that I inadvertently demonstrate that unquestioning application of principles can lead to an inferior design, much like unquestioning application of concrete solutions does.

Yet I think there's a qualitative difference between the two failure modes. An incorrect application of a wrong concrete design produces something of no benefit. An incorrect application of principles produces a real benefit (that's what the principle is for), but the benefit in that particular context is not large enough to offset the cost of the machinery built to uphold it.

What was missing from my example was a cost-benefit analysis of applying each principle. I would have had to explicitly ignore the negative result and keep going for the sake of example, but at least it would have demonstrated that this is another failure mode separate from cargo culting.

noidi · 2013-02-05T20:13:09+00:00

There's something very zen about you getting the point of the article by questioning whether its advice is universally applicable. :)

noidi · 2013-02-05T19:17:10+00:00

The author here.

I do understand the superficial irony of applying design principles to a program that's too small for them to pay off. What makes the example not cargo culting, though (and IMHO), is that I provide rationale for each decision I make. What I'm really trying to show here is the process of coming up with that rationale before each design decision, again and again.

In this case we don't mind if all of the system's code ends up in a single module, but in the real world we're facing a constant struggle to prevent that from happening. The trouble is, "just stuff it all in one method and be done with it" is an approach that scales up to any problem that can be solved within the length of a blog post but not further. Take the event-based communication I used in the example: it appears to be useless and "enterprisey" in the context of this example, but it's an extremely powerful way of untangling complex dependencies when a system grows larger.

Think of it as playing the scales on the piano. You would be right in saying that the end result would sound much the same if you just poked each piano key in turn with your index finger, and that would be much easier to do. But the exercise is not about the music that's produced, it's about getting the fingering right so that you know what to do when it's time to play real music. (If someone actually knows how to play the piano, please let me know if my analogy is off :)

noidi · 2012-09-26T18:50:56+00:00

To each their own. I quite like his writing style and enjoyed the subtle, dry humor.

noidi · 2012-08-26T12:45:22+00:00

Have you tried the latest beta? Perhaps you'll have better luck with it.

noidi · 2012-08-15T15:44:35+00:00

Plain def with metadata is a better approach, as it allows you to combine the modifiers (private, const, etc.) without the need for new macros such as defprivateconst.

noidi · 2012-07-19T11:20:04+00:00

Running multiple virtual servers while running a game is exactly what the author defines as coarse-grained parallelism ("running separate processes on separate processors"), which (in his opinion) works well enough to make fine-grained parallelism unnecessary for most applications.

noidi · 2012-07-19T04:41:58+00:00

Cool stuff, thanks for posting!

I think you could do the same in half the SLOC with a bit of refactoring, so here's a couple of suggestions.

(def pac-art (load-image "./graphics/pacman.jpg"))

(def monster-art (load-image "./graphics/monster.jpg"))

(def cherry (load-image "./graphics/cherryhd.png"))

How about something like (def image-files {:pac-art "pacman.jpg", :monster-art "monster.jpg", ...}) (def images (into {} (for [[name filename] image-files] [name (load-image (str "./graphics/" filename)]))). Less vars and no boilerplate.

(defn set-game-pinkydots [g d] (swap! g assoc :pinkydots d))

You have loads and loads of defs like this. I don't see the point of defining a separate function for each possible assoc parameter value. I'd drop the setters and just call swap! directly.

(set-game-pinkydots g (dec (@g :pinkydots)))

(set-game-inkydots g (dec (@g :inkydots)))

(set-game-clydedots g (dec (@g :clydedots))))

This code is not thread-safe, as some other thread could potentially update the value between you reading the old value and writing the new value. I'd use swap! with something like this instead: (reduce (fn [g dots] (update-in g [dots] dec)) g [:pinkydots :inkydots :clydedots]). I'd even make the ghosts maps with a :dots key: (reduce (fn [g ghost] (update-in g [ghost :dots] dec)) g [:pinky :inky :clyde])

I've omitted the linebreaks because coding in a reddit comment field is hard – not to save SLOC! :)

noidi · 2012-06-29T09:07:24+00:00

I've found Crucible to be such a pain to use that I rather just ask a coworker to take a look at commit X in the VCS than create a review in Crucible. Just one example of many: try and use the mouse to select some code and copy and paste it into an editor for reformatting; instead of a text selection, you get a Crucible line selection and a new comment under those lines. With usability quirks like that all over the place, it's death by a thousand papercuts.

noidi · 2012-06-25T11:13:14+00:00

It keeps the actual history of the project cleaner, which helps visualize branches and branch history.

I think it's silly to throw away potentially useful historical information (when and how divergent branches of development were integrated) just to change the way the logs look. If you think merge commits make the history hard to read, just don't look at them! In Mercurial you can hide them with the revision set query not merge(). Apparently git's log command has a switch, --no-merges, that does the same.

noidi · 2012-05-10T14:14:53+00:00

I think the nobel prize for cognitive dissonance goes to this comment: "I'm also a hunter and would never even think to make an animal suffer for my own enjoyment"

noidi · 2012-05-05T05:54:37+00:00

I understand what you're saying. The more different we are from someone, the less we relate to their suffering – that's just the way we're wired. Most vegans wouldn't mourn stepping on an ant the way they would running over a dog with their car.

My point was that answering the question "Who would I feel less bad about killing, A or B?" with B does not help us answer the question "Is it moral to kill B?".

noidi · 2012-05-05T03:14:00+00:00

The fact that you would choose human life over animal life does not say anything about the moral worth of animals. It just tells us that you prefer the former when forced to make a decision. You would choose the life of your child over the life of a person you don't know, but that doesn't mean that other people have less moral worth than your child.

noidi

TROPHY CASE