Python on traviscj/blog

dancing bull pricing structure

Thu, 04 Jan 2018 00:10:00 +0000

Dancing Bull is a great Korean BBQ restaurant that opened nearby recently. They have this pricing scheme:

Note that the unlimited bulgogi is \$23/person, but the bulgogi a la carte is \$25/grill (with each additional orders after that costing \$9). This raises an obvious question: which is the better deal?

Spoiler: it depends on both how many people you have and how hungry they are.

First, we had to clarify how it actually worked. It’s not clear from the menu, but the “\$25/grill” includes the first order of bulgogi. Introducing $P$ for the number of people, $G$ for the number of grills, and $O$ for the total number of orders, we would pay $$UL = 23\cdot P$$ for the unlimited price scheme vs $$ALC = 25\cdot G + 9\cdot ( O - G)$$ for the a la carte scheme.

snack buying

Mon, 13 Nov 2017 07:01:25 +0000

I got this text message from my father-in-law:

Ok. Soda 1.50 Chocolate bar 1.00 Gum 0.10 Jelly Bean .05

Have to buy exactly 14 items and spend $10

At least one of each.

There are 4 diff combos. (Order: soda, chocolate, gum and jelly bean)

Got 5-2-3-4 3-5-4-2

Can’t get others. Any ideas? :)

I whipped up this solution to check in python:

#!/usr/bin/python3
# created_at: 2017-11-13 13:53:19 -0800

def main():
    solutions = 0
    for si in range(1,7):
        for ci in range(1,11):
            for gi in range(1,101):
                for ji in range(1,201):
                    total = si*150 + ci*100 + gi*10 + ji*5
                    items = si + ci + gi + ji
                    if total == 1000 and items == 14:
                        print(si,ci,gi,ji, total, items)
                        solutions += 1
    print(solutions)

if __name__ == "__main__":
    main()

The core of this solution is the check

python attrs

Thu, 31 Aug 2017 08:42:43 +0000

I came across a very interesting library in a HN thread: the python attrs library.

In particular, this seems like a great way to do the “dumb data objects” they talk about in the end of object inheritance, and also related to (but maybe lighter weight than) zope.interface.

This also seems very similar to what I use autovalue for at work.

One particularly interesting application is a “code database” – using static, checked-in-to-version-control definitions of some data model as a sort of very-fast-to-read, very-slow-to-update “Data Model”. I find this fascinating: Code shares a lot of properties with great data stores: ability to rollback (git revert) and accountability/auditability (git blame). It also makes a lot of fairly hard problems much simpler: you don’t need to poll the database for changes. You don’t need to invalidate any caches. You don’t need to consider a “split brain” environment where half of the in-memory caches have updated but the other half haven’t. You don’t need to consider failure cases of how long the in-memory cache is allowed to be invalid: you just fail to boot up on deploy. (Admittedly, there’s still an opportunity window for split brain behavior for the duration of the deploy, but this is a lot easier to reason about than an essentially arbitrary.)

toy/life data models

Wed, 19 Apr 2017 00:00:00 +0000

I’ve been experimenting a lot with some kinda “toy” data models based on random things that I wish there was a database to query, but isn’t. For example:

What was my average arrival time this week?
How much of my equity has vested before a certain date?
When was the last time we had spaghetti for dinner?

I’ve been doing this with flat JSON files. This is a bit of an odd choice for me; I actually love schematizing data models in protobuf and MySQL and designing proper indices for the data models I work on during work hours.

use the `locale.currency` library function

Fri, 20 Jan 2017 00:00:00 +0000

I had stupidly written a pair of functions like this:

def comma_sep(amount):
    thousands = int(amount/1000)
    remainder = int(amount%1000)
    if thousands > 0:
        return comma_sep(thousands)+","+"%.3d"%(remainder)
    else:
        return str(remainder)
def friendly_from_cents(total_cents):
    pos = total_cents >= 0
    total_cents = abs(total_cents)
    cents = int(total_cents%100)
    dollars = int(total_cents/100)
    friendly = "$"+comma_sep(dollars)+"."+str(cents)
    if pos:
        return friendly
    else:
        return "-" + friendly

This is stupid, because python has builtin support to localize currency:

import locale
locale.setlocale(locale.LC_ALL, 'en_US')
locale.currency(-1800, grouping=True)

I think it’s tempting to fall into these traps, because it always starts simpler: I had some total_cents variable and just wanted to display quick and dirty. The complexity built up gradually, until I had something pretty complicated. Oops.

streaks vs statistical streaks

Mon, 26 Sep 2016 00:00:00 +0000

Hacker News et al are obsessed with streaks, but I think they have some problems:

A single regression resets to zero.
There’s not an easy way to gradually ramp up your streak-commitment over time.

I prefer a different approach: statistical streaks.

Suppose I made a commitment to do something differently on 2016-08-26, and did it for the next 5 days; then my 30-day statistical streak avg = 0.166, but my 5-day statistical streak avg = 1.0.

switching over to https

Fri, 15 Apr 2016 00:00:00 +0000

One of the things I’ve been meaning to do forever is switch things over to https. By “things”, I mean the set of websites I run for some family and friends. I tried it out with my personal website first, then flipped over the rest.

implementation notes

I used the letsencrypt start guide to generate the certificates.
Modified the nginx config to: a. serve ssl/https traffic on port 443 for the given domain with the proper https certificates/etc. b. forward non-ssl/http traffic on port 80 to port 443 for the given domain

verification

It turns out that the nginx configuration files are a little bit error prone. This probably means that I am doing something wrong, like not using some configuration management tool like puppet or ansible or whatever. But for something as small scale as my site, it doesn’t really meet the cost-benefit threshold for learning a new tool/language. I also even considered spinning up a simple one-off configuration generator that I’d need to figure out how to override and extend as needed.

inspired by magicmirror

Sat, 02 Jan 2016 18:45:00 +0000

I’ve been really inspired by the MagicMirror project. The basic idea is getting a piece of mirror glass and putting a monitor and computer behind it, then having a status page show some pertinent information about the day (like weather, calendar, news, etc). So it looks like a regular mirror, but when you look closely, it shows the extra information.

I’d like to put one in the bedroom to replace our tall mirror. That’ll be pretty cool, but it requires a bit of extra thought because our magicmirror setup would replace a tall and skinny mirror, so we’ll probably just want a monitor behind the top part of the mirror. That will require some extra bracing to hold the monitor up in the frame. I’ll need to think about that a while.

black box machine learning

Tue, 15 Jul 2014 00:00:00 +0000

During my Ph.D. I studied optimization algorithms. Optimization algorithms are typically an integral part of machine learning algorithms, and we discussed many machine learning algorithms, but somehow I made it through without doing very much actual machine learning training or prediction tasks.

It turns out that it isn’t very hard to do some very basic machine learning:

pip install -U numpy scipy scikit-learn
ipython
from sklearn.ensemble import RandomForestClassifier
from sklearn import datasets
iris_data = datasets.load_iris()
rfc = RandomForestClassifier()
rfc.fit(iris_data['data'], iris_data['target'])
rfc.predict([6.1,2.6,5.6,1.4])    # yields array([2])
rfc.predict([5.7,4.4,1.5,0.4])    # yields array([0])

language fluidity

Sun, 29 Dec 2013 00:00:00 +0000

I have learned a lot of programming languages over the course of my life. So I wanted to do two things:

Discuss a few effective ways to pick up a new language.
Discuss a few references that I’ve found helpful for some languages. I should start with a disclaimer: I do enjoy learning new languages, but mostly I enjoy creating things in those languages. I’m not sure all the effort I have spent learning many languages would not have been better spent learning many fewer languages to a deeper level, but I do feel like it is extremely important to learn principles, not languages, and to use the best tool for a particular job. Many times principles are most clearly illustrated with contrast between languages, and many more times a particular tool has been a patently poor choice for a particular job.

That being said, it’s important to know your “first tongue” languages in significant depth.

python decorators

Tue, 30 Jul 2013 00:00:00 +0000

I came across something that I think is actually pretty neat. Python supports ``decorating’’ functions, which lets you define behaviors that essentially wrap around a given function. The benefit is that you can write a simple function and decorate it to do something fancier.

I realized I wanted to do this with a simple timing output. Say my function was just something really simple like

def f_plain(x,y):
    print("x + y = {}".format( x+y))
    return x+y
print ("---")
print (f_plain(1,3))

Now, to time it, I could define a function like:

some tips for project euler problems

Sat, 26 Jan 2013 00:00:00 +0000

I wanted to make a list of a few tips on solving Project Euler problems that have been helpful for me while I solve them. These are general principles, even though I do most of my Project Euler coding in Python.

Without further ado:

If the problem is asking for something concerning the number of digits, typically this indicates that the use of the $\log n$ function is warranted.
If the problem is asking for the last few digits, modulo arithmetic might speed it up considerably.
Some might consider this cheating, but looking up some small numbers in the Online Encyclopedia of Integer Sequences is occasionally pretty helpful.
Many problems boil down to: Find numbers with property $X$ and property $Y$. Two solutions are:
- Brute force: Try all numbers with tests of property $X$ and $Y$.
- Find numbers with property $X$ and filter by a test of property $Y$.
- Find numbers with property $Y$ and filter by a test of property $X$.
- Find the set of numbers with property $X$ and the set of numbers with property $Y$. Compute their intersection.

I’ve found that it’s sometimes hard to predict which one will end up being the fastest. It depends on the relative speed of the tests and the generators, and the frequency of finding numbers which have that property.

Meta post - How my blog works

Fri, 27 Jul 2012 00:00:00 +0000

A while back, Sharvil requested a quick overview of how I post stuff to my blog, so I thought I’d post a rundown of it.

At the base, I use a git repository to store files named entryNNNN.txt. Each has the basic format:

title: Meta post: How my blog works
date: 2012/07/27
category: software
---
A while back, Sharvil requested a quick overview of how I post stuff to my blog, so I thought I'd post a rundown of it.
At the base, I use a git repository to store files named entryNNNN.txt. Each has the basic format:

To start a new post and fill in some of this, I have a script called ’newentry.sh’, which determines the latest entry number and adds one to get a new filename (eg, entry0081.txt).

More cracking D-Link Files

Wed, 27 Jun 2012 00:00:00 +0000

Somehow, in the process of a router reconfiguration, I reset the password without the new password getting saved into 1Password. So I found myself locked out of my own router. I was about to reset it, thinking, “Hey, at least I have a backup of the settings from 2 nights ago!” and then realized, “I bet that settings file has the password right in it.”

Googling around a bit turned up this guy, but he only wrote VBA and a Windows binary. His pseudo-code looked pretty easy to translate into Python, so I did just that. Here’s the result: D-Link DIR615 B2 v2.25 Decoder (no encoder, yet…)

tjtestharness - a language-agnostic DVCS unit-test/continuous integration tool

Mon, 26 Mar 2012 00:00:00 +0000

I’ve been wanting to have a way to visualize which unit tests(or sets of them) passed for a given commit, if for no other reason than the sense of accomplishment from watching boxes turn yellow, then green, as they pass tests. The trouble is, I write code in a lot of different languages for a lot of different projects. I also don’t want to bother with running unit tests individually–I want them to run as I perform commits.

tcjblog.py

Fri, 09 Sep 2011 00:00:00 +0000

I’ve now (for the most part) finished a working version of some software I’ve wanted to tackle for a while. I call it tcjblog.py. It’s a blog platform built using jemdoc.py to format simple text files into nice looking HTML. What’re the benefits of this, and features of tcjblog.py in general?

Simple, text file management of blog posts. (I control these with git.)
Ability to include LaTeX markup.
Static HTML for all blog-related pages

Pylab PDF

Tue, 25 May 2010 00:00:00 +0000

I’m in the process of kicking the MATLAB habit and replacing it with Python. Pylab is a reasonable approximation to the 2D plotting capabilities of MATLAB, but by default Pylab doesn’t run on headless(ie, non-GUI) boxes. So on my macbook, where I’m often running things interactively, I have

backend : macosx

and on the faster core2quad machine I send off longer-running jobs to, I used

backend : PDF

in the .matplotlib/matplotrc file.

MySQLdb module in Python on Ubuntu

Sat, 30 May 2009 00:00:00 +0000

To install the mysqldb module in python on Ubuntu:

sudo apt-get install python-mysqldb

Computer Ressurection and Elastic Cloud Experimentation

Sat, 29 Nov 2008 00:00:00 +0000

I was home on Thanksgiving Break with Sharvil, and we decided to revive some old computers. Partly I’d like to experiment with some clustering stuff without incurring CPU time at the AMATH department or Teragrid stuff I’m likely gonna be working on soon with Shea-Brown’s neuroscience research. So, it turns out I resurrected about 5-6 old computers(final tally is still waiting on the number of successful Xubuntu installs on them, among other practical issues(where the hell am I going to put six computers…?): The very first computer I built(a P3 450), P3 700, Dual P2 266, a couple of AMD64 3200’s, and a Sony Vaio P3 733. The cool thing is that the neuron spiking models are basically embarassingly parallel(well, each run isn’t necesarily, but from what I’ve gathered so far, we’re looking for averages over a bunch of them. So, sweet! Again, this would be terrible for actual research, especially against something like TG or even Amazon’s EC2–which is another thing I really need to check out.

Cython

Fri, 09 May 2008 12:00:00 +0000

After I had finally convinced myself to get out of bed this morning to go to my ACMS seminar, I quickly checked my email and my heart sank a little. Today’s talk was on SAGE. Don’t have anything against SAGE, but I thought it was just a big pile of open source packages in a big, heavy install. Sorta cool, but worthless, in other words.

Turns out, I was pretty wrong about that. It is that, but it’s also 70k new lines of code that does a whole bunch of exciting stuff. Near the end of his talk, William Stein mentioned that they had created a new tool called Cython. (Well, extended Pyrex, but… whatever.)

Python Playing

Fri, 28 Dec 2007 12:00:00 +0000

I’ve been playing around with Python a bit more over the break, mostly because I want to be lazy in my code-writing for the forseeable future, plus I’d like to give NumPy a shot, but I want to have a solid background before trying that. One thing that just has not gotten old yet is the ability to assign functions absolutely anywhere in python. You can pass them around like variables, put them in dictionaries, return them from functions, whatever. I mean, I lived in parenthesis for a while in my scheme class, so it’s not like I haven’t been exposed to it, but it’s still damn cool. You can do cool stuff like making a tuple of some index, some value, and the function to process the other two. That makes it so much easier to deal with various combinations of neat datastructures. Anyways, the book I’ve been reading is Dive Into Python, off diveintopython.org. I’m currently at about page 114 out of 327, and I’ve fairly faithfully read most of it up until that point. The format seems slightly frustrating to me, but it’s probably just because it’s such a departure from what a lot of books and tutorials use. It seems helpful and worthwhile in any case.