Wednesday, October 16, 2013

Using an older Mac Mini as a DVR

I'm not a cable TV subscriber, but we occasionally watch shows on broadcast TV that come in over the antenna. Recently, I decided to enhance our setup with DVR functionality using an older Mac Mini (from 2009) that was already connected to the TV. Long story short, I went with the combination of an HDHomeRun tuner, MythTV 0.27, and a Schedules Direct subscription, and things are working great. Some notes on the process:
  • Web searches for "mac dvr" and related terms often lead to EyeTV products and software. I went with the HDHomeRun instead of EyeTV hardware since EyeTV doesn't seem to have anything available in the US that can pull signals directly from a coaxial cable (instead there are analog RCA inputs to get signals from a cable box). I skipped the EyeTV software since MythTV is free and I could deal with the painful setup process.
  • I set up MythTV following the instructions here and here. One issue I ran into was that the setup program would crash on opening for me until I addressed the issue with MySQL time zone tables. Otherwise, things went smoothly, though the process was quite tedious.
  • It took some tinkering to find an appropriate playback profile for my older hardware. Right now, I'm using the VDA Slim profile, which doesn't drop any frames but leaves some interlacing artifacts.
Overall, I'm quite happy with the setup. The MythTV front end interface has some rough edges, but the underlying features are rock solid so far, and you can't argue with the price. It's great to finally have basic DVR functionality; watching TV "live" now seems very primitive.

Sunday, May 19, 2013

Gmail Notifr

I recently discovered Gmail Notifr (via The Changelog), and in spite of the odd name, it's the best Gmail notifier for Mac that I've found. I figure it's time to reduce my dependence on Sparrow, since it's unmaintained, and so far this notifier + Gmail in Firefox is working well (with multiple accounts).

Sunday, April 21, 2013

Infinite Call-String Sensitivity and Object Sensitivity are Incomparable

I just returned from a fantastic week at Dagstuhl, discussing the ins and outs of pointer analysis. I wanted to briefly write up one technical point regarding the comparability of call-string-sensitive and object-sensitive points-to analysis that seemed to not be as widely known as I had thought. For some background on terminology, etc., you can see Milanova et al., Lhoták and Hendren, Smaragdakis et al., or our recent book chapter (not an exhaustive list).

Milanova et al.'s original work on object sensitivity states:

In general, object sensitivity (an instance of the functional approach to context sensitivity [Sharir and Pnueli 1981]) and call chain context sensitivity (an instance of the call string approach) are incomparable in terms of precision.
But, no examples are given to illustrate this point. It's fairly clear how to construct examples showing that k-limited call strings can be more precise than k-limited object sensitivity, and vice versa. But, without k-limiting, i.e., with "infinite" call strings or object sensitivity (ignore recursion for the moment), the question of incomparability becomes a bit murkier. So, here are a couple of examples to show that incomparability holds even without k-limiting.

An example showing call strings to be more precise than object sensitivity isn't too tricky: (The comments name the objects being allocated or indicate the points-to relationships caused by the statement.) A call-string-sensitive analysis analyzes the calls at lines 10 and 11 separately, but an object-sensitive analysis does not, since both have the same receiver object a1. Hence, the object-sensitive analysis computes the imprecise points-to facts z -> o2 and w -> o1. Note that k-limiting plays no role here.

The example showing object sensitivity to be more precise is a bit trickier (and perhaps less widely known): Here, p is a boolean with some unknown value, so z can point to either a1 or a2. With object sensitivity, the call at line 12 is analyzed separately for receiver values a1 and a2, yielding the points-to facts shown. A call-string-sensitive analysis only analyzes the call once, and therefore computes the imprecise facts a1.f -> a2 and a2.f -> a1. Again, k-limiting plays no role. This example shows that object sensitivity is providing a form of path sensitivity that is truly orthogonal to the call-return matching obtained via call strings.

Note that both of these examples are contrived, and it's unclear whether this incomparability has any implications for analysis of real programs, since for the most part, only k-limited variants are used in practice. For an empirical evaluation of call strings vs. object contexts, see Lhoták and Hendren.

Anyway, hopefully this post has been useful in clarifying a small point regarding these analyses.

Friday, February 08, 2013

Long-Form Article Search

There is a lot of long-form journalism and magazine-style writing available for free online these days (see Longreads, Longform, The Feature, etc.). While there are more new articles published each day than most people can keep up with, I've often wanted to search for long-form articles on a particular topic. So, I threw together a quick Google Custom Search:

(You can access the search page directly here.) I didn't spend much time on this, but it turns up surprisingly good results, perhaps because even articles that peripherally mention your search terms are often still interesting. Some examples:

The search returns results from sources that (1) I think have generally good writing, (2) make some / most of their articles freely available, and (3) are amenable to restricting results to longer articles via URL patterns. (I had to exclude a couple sources that I wanted since their sites didn't meet criterion (2) and/or (3).) It's not perfect; e.g., searches for actors / directors will often turn up a lot of film reviews. But, it seems to work reasonably well. If you have any feedback, let me know.