Readability Counts

Before I get too wonky, the bottom line is that, after accounting for inflation, the average total cost for three major expenses (house, car, and education) that a 30-year-old anticipates are only 13% higher in 2013 than they were in 1983. That isn't terrible, since our hypothetical 30-year-old would still break even in that scenario, but the number of people who can't afford to buy a house, car, and education has grown by 25 million (from 75 million people in 1983 to 100 million peoplein 2013), despite all efforts to enhance access to affordable lending for college & housing. To be clear, though, regulations aren't the only pressure on the market, and average salary, for example, has fallen by almost 23% over the same period, even while the median salary has grown by 11%, suggesting a relatively steep salary reduction for low earners combined with a modest increase in the number of high vs low salary earners.

Data

The table below contains the data I collected—with linked sources where applicable. I relied on averages (which can be a misleading statistic) because they were the most readily available information for all categories, so don't exaggerate the importance of these numbers. However, another study recently found similar trends, though the magnitudes differ substantially. (Sure, theirs were compiled by a University of Michigan economist, but I think we all know who's numbers are better.)

One important thing to note is how little the total cost of housing, in particular, has changed. While the "sticker price" of housing has increased, it has largely been at the expense of loan interest rates (which is acceptable to banks so long as they can recoup the difference through fees in combination with volume of sales). In other words, there have not been any real gains in property value over the last thirty years; to wit, rising prices have been almost entirely an artifact of changes in loan financing. Of course, that trick only works once because rates must eventually stop falling, and the ramifications of increasing interest rates will consume more than the associated growth because overall economic activity will decrease when rate increases depress home prices and discourage (or prevent) existing owners from selling and new buyers from investing. (The expected return on a financed investment is low or negative when interest rates are rising because future buyers may be unable to afford the asset.)

Another notable trend is education, where average costs today are 844% of what they were in 1983. Not to mention that some sources suggest that students only financed a fraction of their education in 1983, versus almost all of it today. According to Congressional Budget Office estimates, the government made $41 billion on student loan interest in 2013&which is more profit than all but two corporations in the world, Apple & Exxon Mobile.

The table also shows that an average earner in 1983 winds up with a $110,000 surplus after 30 years, while his 2013 counterpart can expect almost a quarter million dollar shortfall. (As an aside, falling interest rates over the last 30 years created opportunities to cash out equity that are unlikely to repeat with rising rates moving forward; refinancing in the late 90's early 00's would push the surplus closer to $200,000.) Another way to look at it is that an average earner cannot afford an average house in 2013 (although a median earner could).

1983 2013 Cost Terms Total Cost Terms Total House $165.4 30 years @ 13.42% $843.8 $319.0 30 years @ 4.26% $896.9 Car $18.6 5 years @ 13.0% $44.2 $29.2 5 years @ 4.22% $61.6 School $2.4 10 years @ 6.0% $5.6 $21.3 10 years @ 4.06% $47.3 Salary 30 years @ $33.5 $1,004.3 30 years @ $25.9 $778.4 Total $110.8 −$227.4 All data presented in thousands of 2010 dollars, converted using the BLS inflation calculator. Excludes all other costs of living, pay raises or promotions, asset appreciation/depreciation, etc.

Household Spending

I also looked at overall household spending, and I was surprised by how little it has changed in 30 years. Looking at the chart below, which shows five basic categories of household spending for 1984 and 2011 (1983 wasn't captured and 2013 data isn't available yet), you can see that "products" (clothes, food, transportation) have gotten cheaper, while "services" (healthcare) and housing have risen&echoing the findings of the previously-mentioned study by CNN.

Conclusion

As home mortgage interest rates rise, the only way for buyers to afford prices commensurate with the balances on existing homes will be for salaries to rise, with the greatest benefit associated with increases at the lowest income levels (i.e., it is more important to push some of the 100 million people who can't afford a home over that threshold than it is to increase the income of high earners or those who can marginally afford a home). Additionally, we should reevaluate "college for everyone" financing policies based on both the employment prospects and the real costs of high debt-loads for young people. The costs of college are more likely to be controlled by managing demand than by increasing financial aid.

Chessnut is a chess model not a chess engine, i.e., it has no artificial intelligence controller to play chess (it is far too slow to build into a strong engine anyway), and it doesn't have a GUI to facilitate playing a game. But those limitations were intentional; the whole package (excluding unit tests) is contained in three files that take up only about 200 lines of code. And for that you get all the core logic of chess, move validation (including check, checkmate, castling, and en passant)—all in pure Python. For comparison, the full-featured PyChess has 25,000 lines of code. I chose a simple representation of the board in order to make it easy to understand.

That simplicity has benefits for testing, as well. Chessnut passes unit testing with 99% branch coverage using the coverage.py package, and scores 10.0/10 in pylint. That's not to say it's perfect—I'm still finding bugs in it regularly—but, I think it's stable at this point, and certainly ready for public release.

Thus, I built Ben to alternate between two actions, "sting", and "move", and to announce those actions (and more) in the game log. Ben is not a successful AI, but I get a laugh out of thinking about the confusing messages he leaves for opponents, so I think he's a winner.

ben.py

Perhaps the most common misconception is about finding other numbers in the expansion of π. This monologue from Person of Interest is a great speech—but it's not true. We know that π is irrational (proof) and transcendental (proof), which means that the decimal expansion is infinite and never repeats, but there is currently no proof that pi meets the stronger condition of being normal—so we can't say whether every finite sequence can be found in the expansion. A more detailed explanation was offered recently on reddit in response to finding Jenny's number in the expansion of π.

We also learn very little from continuing to calculate new digits of π. It is an interesting computer science problem to find efficient algorithms to compute the digits & compression techniques to store it, but there is very little practical significance since 39 digits of π is enough to calculate the circumference of the known universe to the width of a hydrogen atom, and even less mathematical significance since there are already exact expressions for the value.

I came across this limitation as I was trying to implement a generic linked list. I tried using interface{} types and the reflect package, and while interface{} allows generic type functions, it changes the type (though not the underlying type) to interface{}. I also tried passing in a type argument or constructor function in order to select the proper type at runtime, but both approaches failed because the name of a type is not the same as the type itself.

The word "monad" comes from category theory, and it's reused in functional programming as the name of a pattern that allows pure functions to perform "extra" actions, AKA side effects. The monad pattern is simply the combination of a type constructor, together with a bind() and unit() method. It may help to think of a monad as a container that comes with instructions for packing and unpacking regular data types. But monads are typically unnecessary outside functional programming because impure functions can explicitly perform side effects.

For example, in Python you could use the following code to compose (sequentially apply) an arbitrary list of functions to an input (main effect) and print the result of applying each function (side effect).

Python

def apply(fs, v): res = v for f in fs: res = f(res) print res # This can't happen in a "pure" function return res

Doing the same thing with pure functions requires a monad - which has two functions: unit(), which makes (in this case) a tuple from a single value, and bind() which "teaches" functions that expect a single value what to do with the newly-formed tuple.

Python

def bind(f): return lambda x: f(x[0]), "\n".join([x[1], str(f(x[0])) def unit(v): return v, ""

We can see that they are equivalent like this:

Python

def compose(fns): # fp helper to chain function application return reduce((lambda g, f: lambda x: f(g(x))), fns) # define a starting value and some arbitrary functions v = 1 fs = [lambda x: x*3, lambda x: x+x, lambda x: x**2] res1 = apply(fs, v) # prints intermediate results res2, inter = compose(map(bind, fs))(unit(v)) print inter # prints intermediate results print res1 == res2 # True

In the real world, you don't typically compose arbitrary functions like this - especially not in Python. But monads can also be used to pass additional information into functions, which can be used to create a computational dependency in lazy languages in order to enforce a specific evaluation order - and that allows pure functional languages to implement useful things like Identity, I/O, and Maybe.

It doesn't matter if politicians learn to code if they don't understand the technology to begin with. We will continue to see legislation like SOPA and PIPA, lawsuits against net neutrality from companies that paradoxically commit to support net neutrality, government attacks on privacy, and fracturing from every corner of the political spectrum.

To be fair, not everything about the Internet has been positive - fraud, illegal activity, and other problems remain common. But even after bad ideas are defeated, they find more creative ways and come back, like the cat we all love sharing so much.

It doesn't seem to matter what the evidence shows, nor that world experts say that legislation won't work, nor that the arguments for regulation are often farcical (Verizon is arguing that throttling internet traffic is an issue of free speech protected under the First Amendment), or that we see examples of literally Orwellian practices. Because even when the attacks on the Internet fail, we'll do it to ourselves by locking the internet, and locking our devices.

This isn't about cat pictures, email, social networking, or any other single use of the Internet. The Internet represents the collective knowledge of mankind, and it is arguably the greatest human achievement in history. (There is a reason that the UN declared internet access a basic human right.) And we're throwing it away because people who don't understand how it works are making laws based on the input from people who only want to make more money from it.

Quoting the HN source:

Instead, Congress requires student loan borrowers to initiate an adversary proceeding, a separate lawsuit filed within the bankruptcy case, to prove that repaying their student loan debt would be an "undue hardship." … One, that the borrower and any dependents cannot maintain a minimal standard of living based on current income and expenses; two, that additional circumstances indicate this is likely to be the case for a significant portion of the borrower's repayment period; and three, that the borrower made a good faith effort to repay the loans.

There is too much code involved to cover everything, so the code snippets below only show enough to understand the principle, not necessarily all the code required for an app to function. However, I've tried to link to the source material that led to my solution whenever possible.

Custom User Model:

Always use the get_user_model() import pattern to access the User model (in the import section of your modules). Lots of third-party modules seem to miss this...

Python:

try: from django.contrib.auth import get_user_model User = get_user_model() except ImportError: from django.contrib.auth.models import User

I followed this guide to use the email field as the account username, then added a false username field with the @property decorator (this is hack-ish, but lets your model work with apps that don't fully implement the Django 1.5+ User model - like django-registration). You also need to refer to an unused username field as an argument in the PlayerManager class methods. Also notice that the create_user() method uses email.lower() instead of UserManager.normalize_email(), which is important if you want to use case-insensitive emails for authentication (discussed below).

Python:

class PlayerManager(UserManager): … def create_user(self, username=None, email=None, password=None, **extra_fields): email = email.lower() # force email addresses lowercase … class Player(AbstractBaseUser, PermissionsMixin): USERNAME_FIELD = 'email' … @property def username(self): return getattr(self, Player.USERNAME_FIELD) @username.setter def username(self, value): pass

The default backend from django-registration can be used with a custom User model if you override the user creation form class & the urls.py registration view. The .as_view() method optionally accepts a form_class argument that can be used for this. So in your yourappRegistration.urls module:

Python:

urlpatterns = patterns('', … url(r'^register/$', RegistrationView.as_view(form_class=PlayerCreationForm), name='registration_register'), … )

The user creation form inheriting from the User class combined with the get_user_model() pattern produces a more generic form for user registration. Remember to always use the USERNAME_FIELD (set in the custom User model class) to reference the username field in your code (better than relying on the .username property hack above). So in your yourappRegistration.forms module:

Python:

class PlayerCreationForm(forms.ModelForm): … class Meta: model = User fields = (User.USERNAME_FIELD,)

The registration view from the default backend does not use the generic User model patterns from Django 1.5+, but it can be extended by creating a module yourappRegistration.views:

Python:

class RegistrationView(BaseRegistrationView): … def register(self, request, **cleaned_data): username = cleaned_data.get('username') email = cleaned_data.get('email') password = cleaned_data.get('password1') … make_user = RegistrationProfile.objects.create_inactive_user new_user = make_user(username, email, password, site) …

There are actually a number of forks from the baseline django-registration framework to address the custom User model issue and work with email addresses as the username, but I was trying to stick with the main branch for all dependencies so I ended up using most of a custom registration backend.

User Authentication

I followed this guide to using case insensitive email field for authentication - a much better solution than Stack Overflow answers [1] or [2].

Python:

class CaseInsensitiveBackend(object): … def authenticate(self, username=None, password=None): try: user = User.objects.get(**{User.USERNAME_FIELD: username.lower()}) if user.check_password(password): return user except User.DoesNotExist: return None def get_user(self, user_id): try: return User.objects.get(pk=user_id) except User.DoesNotExist: return None

Because the project uses a dedicated app for all user management functions, the login/logout buttons in the rest-framework views aren't linked by default. That can be fixed in the yourapp.urls module:

Python:

authpatterns = patterns('django.contrib.auth.views', url(r'^login/$', 'login', {'template_name': 'registration/login.html'}, name='login'), url(r'^logout/$', 'logout', {'template_name': 'registration/login.html'}, name='logout'), ) urlpatterns = patterns('', … # link rest_framework auth views to django-registration views url(r'^accounts/', include(authpatterns, namespace='rest_framework')), … )

Miscellaneous & Notable Errors

Authentication emails get sent with www.example.com/activate/<key> by default because of the default value in the Sites database. You can edit the database entry directly using the admin site (if configured), or you can load initial data from fixtures.

Deploying to Heroku via git (as described here) initially failed. The solution turned out to be recreating the git repository and the app via the heroku toolbelt CLI.

Postgre sql was harder to configure than sqlite3 (during development), but it wasn't well documented that the database must be promoted in order to set the relevant environmental variables for use by the app.

I went overboard with the .env file configurations, abstracting several variables from settings.py that caused some bizarre errors when using manage.py. In particular, only the default actions from django were available because the value of SECRET_KEY wasn't loading properly from .env; leave the secret key alone in settings.py.

I ran into two problems with Google Analytics: first, the dashboard didn't show "tracking installed" until I added the legacy ga.js snipped to the template <head> (as outlined here), and second, the dashboard seemed unhappy because I had two accounts pointed to heroku apps (both using default urls that end in herokuapp.com), when what I needed was two profiles under a single "Heroku" account.

There seems to be much ado about serving static files from S3 or CDN instead of from Heroku, but the Heroku guide worked immediately for me, and was a lot simpler than the S3 write-ups. The only hangup I had was that collectstatic required an empty /static/ directory in the project - which git doesn't support. The general consensus is to add a .gitignore file to the folder.

Requirements

requirements.txt