Bob Gardner

C++ Function Try Block

Wed, 06 Mar 2024 00:00:00 +0000

Most of my code reviews are for C++ code and every so often, a commit or review comment reminds me of a nuanced C++ feature I need to study more closely. Recently, it was a teammate leaning on the function try block, a feature I usually avoid because it behaves differently depending on where you use it.

A function try block lets you wrap an entire constructor, destructor, or free function in try { ... } catch { ... }, giving you access to parameters when an exception is thrown before the body even runs. On paper that sounds simple, but the rules change just enough between constructors, destructors, and regular functions that it’s easy to shoot yourself in the foot.

This post is the field notes from that review: when the feature helps, the traps I bumped into, and why I still reach for it only when there’s no cleaner option.

Constructors

The main selling point of the function try block is that it allows you to handle exceptions thrown during the initialization of member variables in a constructor that otherwise could not be caught by the class author.

class my_class {
 public:
  my_class(std::string str) try : str_{str} {
    // A catch block here would not catch exceptions thrown by the member
    // initializer list, in this example, the std::string copy constructor.
  } catch (const std::exception& e) {
    // You can log, modify the exception, throw a different exception, or abort
    // the program, but you cannot use a return statement (compiler error).
    // The constructor parameters are available here, which is especially useful
    // for logging.
  }  // implicit "throw;" here

 private:
  std::string str_;
};

In real production code, I’ve seen this feature used for logging. Another valid use case is to throw a different exception, e.g. at an API boundary.

The implicit throw; at the end of the catch block is a bit of a gotcha. It makes sense if you consider that the constructor is expected to fully initialize the object, and an exception thrown during construction would leave the object in a partially constructed state.

Destructors

The implicit behavior varies for constructors, destructors, and regular functions, and to me, makes it too complicated to generally recommend using outside of constructors and macros (more on that later).

Function Type	Implicit Behavior	Explicit Return Statement Allowed
Constructor	`throw;`	No (illegal, compiler error)
Destructor	`throw;`	Yes
Void-returning function	`return;`	Yes
Non-void returning function	`return;`, (undefined behavior, may generate compiler warning)	Yes

One of the other use cases I thought of for the function try block is to make it easier to implement a noexcept function without having to indent the entire function body. And for regular functions, this is the implicit behavior if the end of the catch block is reached. But for destructors, where the consequence of not catching an exception is aborting the program, the implicit behavior of the function try block is to rethrow the exception, just like constructors. Though unlike constructors, you can use an explicit return; statement to suppress it, which makes sense because the object is already fully destructed and the caller can’t continue to use it (unlike a constructor). Maybe the reason that destructors implicitly throw; is because the function doesn’t have a return type and can’t signal that it violated its postcondition, requiring the catch handler to explicitly spell out via return; that it handled the exception.

Example:

class function_try_dtor {
 public:
  ~function_try_dtor() noexcept try {
  } catch (...) {
    // handle exception
    return;
  }
};

While Clang recognizes this as correctly implementing the noexcept specification, MSVC still emits a warning:

warning C4297: 'function_try_dtor::~function_try_dtor': function assumed not to throw an exception but does
<source>(7): note: destructor or deallocator has a (possibly implicit) non-throwing exception specification

Because of this, I recommend implementing noexcept destructors with normal try-catch blocks inside the destructor body.

To wrap up constructors and destructors, another gotcha is that accessing member variables in the catch handler is undefined behavior. In practice, Clang emits a warning, but MSVC does not.

Regular Functions

For regular functions, the implicit behavior if the end of the catch block is reached is to return, which is useful for implementing a noexcept function. But, if the function has a non-void return type, it’s undefined behavior if the catch block ends without an explicit return or throwing an exception. Clang and MSVC both emit a warning for this case.

I have seen a few functions that use function try blocks to handle exceptions, e.g. by logging and suppressing the exception. In my own code, I prefer to just indent the entire function body and use a normal try-catch block, or introduce a separate helper function to avoid mixing logic and error handling in the same function.

void private_api();

void function_try() try {
  private_api();
} catch (const std::exception& e) {
  // handle exception
}

void inner_try() try {
  try {
    private_api();
  } catch (const std::exception& e) {
    // handle exception
  }
}

For non-void functions, I think it also makes it clearer that the function with the try-catch block in the function body is still responsible for returning a value.

Which do you find more readable?

Where I’ve seen the benefits of this feature outweigh the complexity is for handling exceptions consistently at an API boundary. For example:

[[noreturn]] void rethrow_current_exception() {
  try {
    throw;
  } catch (const std::exception& e) {
    // log, modify, throw a different exception, or abort the program
  }
}

#define FOO_API_BEGIN try
#define FOO_API_END catch (...) { rethrow_current_exception(); }

void foo_api() FOO_API_BEGIN {
}
FOO_API_END

If these macros were instead used within the function body, the entire function would need to be indented, which seems unnecessary, or they would immediately call into a helper function, which adds more reading/debugging overhead and potential for bugs. A drawback of these macros is that contributors need to be educated on their use, but an advantage is that it’s clearer to see that functions using these macros are handling exceptions consistently.

Conclusion

I generally avoid using the function try block because of the complexity and the potential for undefined behavior. I think it’s more readable to use a normal try-catch block, but will use it for constructors and macros when it’s the best tool for the job.

I hope you’ve found this post a useful supplement to the cppreference page for summarizing the differences in implicit behavior and allowed explicit behavior, as well as practical use cases and gotchas.

Appendix: Rust Approach

I use Rust for hobby projects and I often find it interesting to compare how Rust addresses these problems. In Rust, there aren’t constructors, just regular functions that return a new instance of the struct or a Result with an error. The fields of the struct are initialized in the function body and the function must explicitly handle any errors.

struct MyStruct {
    num: i32,
}

impl MyStruct {
    fn new(str: &str) -> Result<Self, Box<dyn std::error::Error>> {
        let num = str.parse()?;
        Ok(Self { num })
    }
}

Here MyStruct::new propagates the error from str.parse to the caller via the ? operator. Values are moved into the struct fields and unlike C++ move is implemented by the compiler, so it’s not possible to write a throwing move.

That just leaves destructors. In Rust, the Drop trait can be used to add custom code within the destructor.

pub trait Drop {
    // Required method
    fn drop(&mut self);
}

As you can see, the drop method can’t return anything, so there’s no way to signal that the destructor failed. As a convention, implementors of Drop::drop suppress any errors that occur, but callers interested in manually handling the error can explicitly call a separate method that returns a Result. An example of this in the standard library is std::fs::File and its sync_all method. And compared to C++, implementations of Drop::drop can still reference the fields of the struct without undefined behavior. It’s important to note that panicking in drop() can lead to surprising behavior, so it’s generally avoided. Another gotcha is that Drop::drop is synchronous and today async cleanup doesn’t have a standard solution (1).

Compared to C++, I find Rust’s approach to this problem more consistent and easier to reason about because it’s more explicit and more consistent across different types of functions.

Memory Jogger Update

Wed, 20 Oct 2021 00:00:00 +0000

Memory Jogger is a program I wrote to help me find interesting articles and videos I had saved in Pocket. I wrote about it previously in this post. It started as a program to send me daily email digests of items I had previously saved that were related to current events (via Google Trends data).

Mostly it was to help me prioritize reading some of the thousands of unread items that I’ve saved over the years. But I also thought that it would make current events more meaningful by reading historical context and commentary. Sometimes it worked as you’d expect, for example, when Hamilton came out on Disney+, it reminded me of the original New York Times article from when the play came out in 2015. Unique words like “Pokemon” also returned relevant results. But other times, the articles and videos in the daily email digest were completely unrelated to the Google Trends results.

This is mostly expected. I used the tf-idf algorithm I learned about in my first internship to implement search. tf-idf helps when search terms contain a mix of common and unique words, e.g. “Pokemon” is rare, but “The” is very common, so “The Pokemon Game” would weight articles that contain Pokemon higher than articles just about games (assuming “Pokemon” is less common than “game” in the document collection).

But the problem wasn’t the search relevance, it was how I use email. I try as hard as possible to keep inbox zero, using Gmail inbox sections to triage emails based on “Needs Action/Reply”, “Awaiting Reply”, “Scheduled”, and the rarely used “Delegated.” But where do these email digests fit in? They don’t! I don’t need a longer to-do list. Instead, I want “pull”, not “push”. Review these items when I have time, but without the guilt and annoyance of push notifications and “unread” messages. I thought for surfacing “trending” articles an email digest was the right UI, but I didn’t think about how these emails would actually fit into my life.

For a positive surprise, I found I clicked on the irrelevant items as often as the relevant ones. Even if the articles in the digest were completely unrelated to what was trending at the time (same words, but different context), it was still fun to read items I had saved years ago. Or, I knew I didn’t care about that item and could just archive or delete it.

So, in 2021, I’ve been using Memory Jogger completely differently. Instead of an email digest that sends me notifications and adds to my to-do list, I wrote an interactive program to just return random items from my Pocket, with commands to quickly archive/delete/skip items. This interactive program interacts with the email digest program via subprocesses and sharing a SQLite DB.

Sometimes, I don’t even use the interactive program. I just load the database in DB Browser for SQLite and then execute the subprocesses manually, e.g.

memory_jogger saved-items archive --item-id <id> 

or even better, create an alias and then just run mja <id> or mjd <id>.

I’ve been slowly cleaning up my Pocket and have enjoyed reading the articles and watching the videos. No notifications, no “unread count”, no search algorithm, just sync, SQLite, and RNG to guide me.

Announcing Memory Jogger, relevant email digest for Pocket

Sun, 12 Jul 2020 00:00:00 +0000

I am excited to announce that I recently open sourced Memory Jogger, an app that I built and have been using for the past few months that emails me unread articles and videos I’ve saved.

From the README:

Finds items from your Pocket library that are relevant to trending news. I have thousands of unread Pocket items and Memory Jogger enables me to find new meaning in articles and videos I saved years ago. I deployed Memory Jogger to Heroku and set up a daily job to email me unread Pocket items based on Google Trends results from the past two days. Memory Jogger is written in Rust.

I love Pocket and have used it daily since 2013. I typically read news sites or forums such as Hacker News or Reddit, and the original articles and comment sections frequently link to tons of interesting discussions or additional information that I don’t have time for now but want to save for later. As of the time of this writing, I have 5,575 unread items :) I sometimes search these items on-demand, e.g. when researching something for work or fun, but other times I wished there was a way to automatically surface relevant items as an alternative to browsing Hacker News / Reddit. So I built Memory Jogger!

Product Decisions

I’ve had this idea on the back burner for years, but when I started this project in February 2020, I still had questions about how I wanted to use an app like this. I made a couple of key decisions in the beginning:

email digest as the primary interaction model
hosted web service with simple UI, available for multiple users to sign up
Google Trends for determining what is “relevant”
Heroku and PostgreSQL database backend
Rust for the implementation language

I ended up revisiting some of those decisions later as well as making a few other ones:

multi-user capable, but no hosting for other people
web UI deprioritized given CLI is good enough for a single user
prioritize better local experience and SQLite support

I quickly settled on a daily email digest that would be coordinated by a program deployed on a server. I didn’t want to rely on my laptop being on as I don’t use it daily. I’ve used Heroku for years for various side projects (e.g. Dancing Together) so I knew what I was getting into :)

For determining what is “relevant,” I chose Google Trends, which tracks the most searched terms on Google over time. This is an area that can be improved in the future (e.g. Twitter trends, topics you are following, etc.), but Google Trends has been good enough for now. At first, I thought about only returning random results, but my partner, Nicole, thought I may enjoy reading timely articles more. That turned out to be a great decision! And the funny thing is, because of false positives, some results are still random, hilariously so.

For personal projects, I try to be as agile as possible to stay motivated, so here’s how I practiced that for Memory Jogger:

Investigate Google Trends API. There is no official API, but I found https://github.com/pat310/google-trends-api which has several hundred GitHub stars and was easy enough to read. I downloaded it locally and played around with it to figure out the HTTP request/responses and tried them out in Postman. Google Trends will work :)
Create a Rust program to query Google Trends. At this step, I discovered Google Trends prepends all HTTP response bodies with )]}', (probably to make parsing harder for web scrapers?).
Add initial Pocket support. At this point, the program can query Google Trends and use the search parameter on Pocket’s retrieve API to find relevant items. Yay! The proof-of-concept is complete.
Add initial CI. Now I submit changes via Pull Requests and use GitHub Actions to build the program and run Clippy on it.
Add frontend and deploy the app to Heroku. I chose actix-web because I had recently used it for another personal project and wanted to explore the actor concurrency paradigm more. The first server program just had a single endpoint to proxy Google Trends requests so I didn’t have to worry about authentication/authorization.
Improve email output based on experience reading the emails.
Start a project to improve relevant results. I started syncing Pocket items to the database to enable custom text search. I learned about tf-idf during a college internship and was excited to try it out.
More email output improvements (add trend link, fallback URL because there isn’t a stable URL to the Pocket Web interface for a given item)
Decide to prioritize running locally, so start cleaning up codebase (remove web service, remove JS prototype code, simplify codebase)
Add SQLite support
Prepare to open source, writing docs and improving UI/UX as I go
Add integration tests that exercise everything but sending emails

Because I prioritized the substantial part of the application first – syncing Pocket items to the database, implementing text search, sending emails – I had an MVP for myself quickly (within a few days). After using the MVP daily, I prioritized improving search and tweaking the email/command line output, so the app kept getting more useful for me.

For example, at first, I relied on Pocket’s retrieve API which includes a search parameter. That API is limited to searching item titles and URLs and I wanted to try other search algorithms to improve results, so I started downloading saved items to the database. I used simple term-frequency search on article titles and URLs to mimic the Pocket API. From there, I started including article excerpts (found by Pocket) to the term frequency searching.

After using it successfully for a few months, I decided against supporting other users. While I was excited to share this project with other people, I didn’t want to be responsible for their Pocket data. With that in mind, I updated my priorities to make Memory Jogger easier to run locally by adding support for SQLite and making the email portion of the app optional (e.g. to use OS notifications).

Notable Implementation Details

The PostgreSQL and SQLite parts of the codebase “look” very similar, but use different types. The implementations can probably be converged using generics to some extent, but they’re not identical. For example, SQLite doesn’t support a RETURNING clause, so you need to perform a load immediately after insertion (in the same transaction), whereas PostgreSQL supports returning the inserted item.

Thank You

Thank you to the contributors to diesel, reqwest, structopt, and actions-rs, which were the major libraries that Memory Jogger relies on. In particular, each one has awesome documentation which has made them simple to integrate.

Photoshop 2020 Launch

Mon, 06 Jan 2020 00:00:00 +0000

I am excited to announce that Photoshop 2020 has shipped and is my first desktop release since I joined the team in July! When you launch the Photoshop 2020 app one of the initial loading screen lists the Photoshop team members and, if the entropy is just right, you’ll see my name listed (it randomizes the non-leadership team members).

Alternatively, the Photoshop team members can be listed via Photoshop > About Photoshop... on macOS.

Because of my work on the Photoshop Imaging Engine (PIE) team, I also have contributed changes to the new Adobe Fresco app that recently launched on iPad and UWP. Notably I contributed locale-aware, case-insensitive, digits-as-numbers sorting to the cloud documents organizer, among a number of bug fixes. It’s an exciting time to be contributing to the Photoshop ecosystem!

Web Scraping with Jupyter Notebooks

Sat, 04 Jan 2020 00:00:00 +0000

Last year I worked on a web scraper to automatically download Creative Market’s Free Goods of the Week. Each week, Creative Market sends an email to subscribers to download these 6 free assets. Subscribers then log in, go to https://creativemarket.com/free-goods, and then click one or both of the “Sync to Dropbox” or “Free Download” buttons. My partner was manually doing this each day and when I was looking for a software project to work on, this seemed like a good candidate for automation that would remove a small, but minor inconvenience of hers.

The GitHub repo is here: https://github.com/rgardner/design-asset-utils. It has been archived because Creative Market has since disabled scrapers from accessing their site. Their whole website (not just the log in page), now requires passing a Google reCAPTCHA test if it suspects an automated system is being used. For what it’s worth, their terms of service seem to allow automated systems as long as they are using the service fairly (e.g. no resharing assets, use rate limiting, and no malware). But I knew they could break web scraping anyways. c’est la vie. While this project is dead, I thought the technique could be valuable to others, hence the blog post.

Web Scraping

I chose Python and Jupyter Notebooks because I wanted an interactive development experience when working on the web scraper. I had worked on web scrapers in the past (e.g. https://github.com/rgardner/citi-bike-notifier) and I found the development experience painful.

First, when the website UI changes, you need to be able to see the contents of the new page to be able to diagnose and fix the scraping code. For example, an error like selenium.common.exceptions.NoSuchElementException: Message: no such element: Unable to locate element: {"method":"id","selector":"input-username"} doesn’t tell you if the element has simply been renamed or if you’ve been redirected to a completely different page.

Second, to reduce the dev inner loop, you want to be able to cache the state of the website to avoid re-logging in every time, or slowly clicking buttons in the correct order. So you run the script under a debugger, make the fix, and then re-run the script from the beginning. But with Jupyter Notebooks, you can edit and continue, edit the same cell repeatedly, or execute the cells out of order. Jupyter Notebooks can also display images inline, which makes it easy to take and display a screenshot when a scraping exception occurs.

My Jupyter notebook is here: downloader.ipynb. It uses environment variables to receive input (following the 12 Factor Methodology), enables verbose logging to stdout, which displays after each cell in the notebook, and defines a function log_error to display a screenshot.

def log_error(driver):
    display(Image(driver.get_screenshot_as_png()))

I use it like this:

try:
    driver.login(CREATIVE_MARKET_USERNAME, CREATIVE_MARKET_PASSWORD)
except WebDriverException:
    log_error(driver)
    raise

Note the screenshot does not display when running from the command line like so:

jupyter nbconvert --execute --stdout downloader.ipynb

For this project, I put some web scraping code that I intended to share with a test script into a common Python module called creative_market.py.

Putting it all together

To run the notebook non-interactively, use:

jupyter nbconvert --execute --stdout downloader.ipynb

This app was deployed to Heroku and only needs to run once per week. Heroku doesn’t have an easy way of scheduling jobs, so I wrote a module called clock.py which uses APScheduler to schedule the downloader to run every Monday:

import subprocess

from apscheduler.schedulers.blocking import BlockingScheduler

SCHEDULER = BlockingScheduler()


@SCHEDULER.scheduled_job('cron', day_of_week='mon', hour=17)
def scheduled_download():
    print('Scheduling downloader...')
    return subprocess.run(
        ['jupyter', 'nbconvert', '--execute', '--stdout', 'downloader.ipynb'])

I also wrote a test script to scrape Creative Market and confirm that the links were successfully clicked, if not, notifying me via email. That is scheduled to run a few minutes after.

Conclusion

The full project is here: https://github.com/rgardner/design-asset-utils. I hope you find it useful!

Windows 10 Launch

Wed, 29 Jul 2015 00:00:00 +0000

Last week I attended the awesome Windows & Devices Group scavenger hunt at Seattle’s EMP Museum. One of the exhibits there featured the amazing work of Chuck Jones, an animator, cartoon artist, and more from Spokane Washington. I grew up watching Bugs Bunny, Daffy Duck, and Road Runner cartoons on Boomerang, and it was pretty cool to learn more about the man behind them. At the exhibit, there was one of his quotes on the wall:

All great endeavors are 90% hard work and 10% love and only the love should show

I’ve been running Windows 10 since day 1 of my internship, through the good builds and the bad (builds are just versions of the OS). It’s come a long way in the two months I’ve been here and I’m very excited for its road ahead.

Windows 10 releases today. My hope is that only the love shows.

Raspberry Pi Console Cable

Wed, 10 Jun 2015 00:00:00 +0000

Where have you been all my life.

That’s how this cable makes me feel. Let me show you a magical cable that allows you to log into the Raspberry Pi shell from your computer, be it Windows, Mac, or Linux. If you are connecting to a Raspberry Pi 1 model, then this is all you need. For the Raspberry Pi 2, you will need an external power supply to power the Raspberry Pi, as the console cable does not supply enough power.

That’s it. Four pins on one side, a standard USB 2.0 plug on the other end. After at most 5 minutes of software installation, you can now connect the console cable to your computer and Raspberry Pi and voilà, you can now log in to your Raspberry Pi on your laptop.

I won’t go into much detail here on how to get this amazing setup working with your hardware, the Adafruit tutorial on this topic does a much better job. But what I will say, is that after installing the drivers and connecting the console cable to my Raspberry Pi and laptop, I only have to run the command:

screen /dev/cu.usbserial 115200

to connect to my Raspberry Pi from my Mac.

After a semester and a half of pain in my energy research because of networking issues and having to find the rest of the computer - keyboard, mouse, display, and cables - this little cable is a godsend.

Here are some cases where the cable is already helping me:

I set up a new Raspberry Pi without a keyboard and monitor.
I misconfigured the network interface on the Raspberry Pi and couldn’t connect via SSH, so console cable to the rescue!

I am a big fan of Adafruit, so here’s a link to buy it from them. You can also find similar cables across the net, but YMMV. While you don’t need this cable to use the Raspberry Pi, it allows me to fix problems faster and get on with my research.

Microsoft 2015 Summer Internship

Sat, 07 Feb 2015 00:00:00 +0000

I am very excited to announce that I will be joining Microsoft’s Core Group this summer. I do not know what specific team I will be working with, but I hope to work in their Internet of Things or Windows OS groups.

It’s been a very exciting year for Microsoft. Just this week they open sourced the .Net Core runtime, which has builds passing on both Windows and Linux, with Mac OS X support coming later this year. They also announced a partnership with the Raspberry Pi Foundation to allow you to run Windows 10 on the Raspberry Pi for free! To my understanding, you can develop applications on Windows desktop and then deploy them to Raspberry Pi’s. As someone going through the process of developing Python applications on a Mac, testing them on Windows, and deploying them to a Raspberry Pi running Raspbian, I can tell you that an easy deployment system sounds very attractive.

Why Technology and Liberal Arts?

Thu, 31 Jul 2014 00:00:00 +0000

Through secondary school I loved all of the subjects. But inevitably, there were days where homework was not what I felt like doing. On these days, I found myself using homework from one subject to avoid the homework from another. Math would trump Spanish, and Spanish would pummel English. While eventually it all was all complete, I enjoyed watching as my interests became apparent in my decisions.

Despite avoiding my English homework, I really did enjoy the class. I loved reading books like The Kite Runner, Reservation Blues, and We. Speaking of which, if you haven’t read We by Yevgeny Zamyatin, I highly recommend it. It’s a dystopian future novel commenting on the Russian revolutions of the early twentieth century (We predated 1984, Brave New World, more well known books in the genre).

I feel fortunate to have enjoyed my classes and my schooling in general. And beyond just school, I am most grateful that I love learning.

When it was time for me to start deciding what my academic focus would be in college, I knew the most important factor would be that the subject would continue to evolve and generate more information for me to learn.

Always be learning.

Ideally, work would mix constrained and unconstrained problems, forcing me to think creatively both in a small problem space and when confronted with a blank canvas. So I found computer science and economics.

Found isn’t the right word; these were the two fields that I spent the most time outside of school learning about. They also shaped some of the electives I took, Introduction to Programming and Introduction to Computer Science, and what I would focus on when I had more flexible homework assignments.

Learning is at the heart of computer science and economics. As the fields grow, researchers discover more applications of their work affecting many other fields. For me, I find both of these fields the most interesting when they are applied to other research areas - but especially so when applied to each other.

This past January, I read a collection of essays on open source software development entitled The Cathedral and the Bazaar by Eric S. Raymond (ESR). Named after the essay of the same name, his essays contrast two models of software development: proprietary (cathedral) and open source (bazaar). In many of his essays, ESR dives into the economics of software. Software is fundamentally different than most other products sold on the market. Software can have a high development cost, but will cost close to nothing to reproduce. Some software is even incredibly cheap to develop. Think of the number of weekend projects that make it into the App Store, which Apple is cracking down on.

Economics is all about making decisions while facing constraints. Money, time, memory, clock cycles, economic growth, latency, storage costs - don’t forget about gravity! Economic modeling starts with generating realistic constraints that ultimately determine the accuracy of your predictions.

Economics and computer science are not actually that different from each other.

The best thing about both of these fields is that they change the way you think. Tyler Cowen explains in An Economist Gets Lunch why food quality in the US decreased during prohibition and why great barbecue restaurants also serve excellent breakfasts. In The UNIX Philosophy, Mike Gancarz draws upon Ken Thompson and others to distill nine essential key points for adherents to the Unix philosophy.

Small is beautiful.

Make each program do one thing well.

Build a prototype as soon as possible.

Choose portability over efficiency.

Store data in flat text files.

Use software leverage to your advantage.

Use shell scripts to increase leverage and portability.

Avoid captive user interfaces.

Make every program a filter.

Each of these precepts influences the way I approach problems, both in software development and in my day-to-day life.

This is the power of economics and computer science: both affect the way I think about and approach problems.

To close, here are three key points from the How To Become a Hacker appendix to ESR’s Cathedral. I argue that these ideas are ingrained in economists and computer scientists alike. They are also what excite me most about my future in both of these fields.

The World Is Full of Fascinating Problems Waiting To Be Solved

Nobody Should Ever Have To Solve A Problem Twice

Boredom And Drudgery Are Evil

Always be learning.

Meatless January

Wed, 08 Jan 2014 00:00:00 +0000

During January 2014, I will not be eating meat. More specifically, I will be a lacto-ovo-pescetarian, meaning I will still consume dairy, eggs, and fish. When I first indicated interest in this at the end of 2013, I received mixed reactions. Some strongly for, others neutral, and a surprising amount of people who were strongly against. I want to begin this discussion by explaining why I am doing this and will conclude with an explanation for the responses I received.

Why am I doing this?

I want to eat better. I do not consume an unhealthy amount of steak, chicken, and bacon. Rather, I resist experimenting with other foods because of the comfort meats provide me.

Many of us have seen the videos of turkeys being mistreated. Cows that never leave the factory, chickens and pigs so large that they can no longer walk. This hasn’t been enough of a deterrent for me to stop eating these animals. It’s not because I don’t care about the way these animals are treated, but rather I don’t have faith in the ‘organic’ and ‘grass-fed’ labels on these foods.

Reactions

From vegetarians, all of the people I spoke to understand my reasoning and supported my choice. They stressed the importance of meal planning and getting all of the required vitamins and minerals. All understood my hesitation for a larger commitment.

From my friends who were upset with my choice, there were two common concerns: (1) my health, and (2) future indoctrination from vegetarians. For my health concerns, I shared my eating plans and the foods that would help to make up for the lost vitamins and minerals. For the second camp, I explained that I would not pressure others nor would I look down upon my meat-eating counterparts. While most of the vegetarians I know have never chastised me for my eating choices, there have been at least two in my life that have become upset with me or my friends when dining out or discussing vegetarianism. It is this vocal minority that gives a bad rap to vegetarians.

Conclusion

Will I continue this into February and beyond? I’m not sure. At the moment, I am liking its effect on my body. I am eating more fish, eggs, and fruit, the chief goals of this experiment. The occasional headaches remind me when I need to eat more protein and the other important amino acids that meats would normally provide me. As I do more research and adapt my diet to make up for these lost nutrients, it becomes easier to think about continuing this meatless streak. If anything, just to learn more about my own body.