Andrews Website Feed

SQL schemas should have documentation strings

2013-05-16T00:00:00-04:00

SQL schemas should have documentation strings

One thing I spend a lot of time doing at work is picking apart applications written by people who have come before me and left leaving nary a trace of their intentions. Software developers should write more comments. It’s either a form of hubris to think that you will be the last person to see your code and you will never need to reread it, or a form laziness to simply not care and take the time to type some simple, high-level documentation into your code.

However, occasionally it’s not the developer’s fault that there are no comments. Sometimes commenting just doesn’t make as much sense. One such place is in SQL schemas. SQL tables and views are generally defined by typing in some SQL code at a command prompt. Alternatively the code can be written to a .sql file and run as a script. In either case, comments can be added through the standard “/* */” syntax available in C, but the comments aren’t saved with the schema in the database. If one saves the .sql file it can be referred to, but only if a .sql file was used and it was saved, which is often not the case. So when exploring a new database for the first time, one is often reduced to divining how it worked by reading table and column names and parsing the source code which is supposed to make use of it.

This is a pain in the ass. Sure, everyone would like to think that their database schema is simple and self documenting; that each table has a descriptive name saying exactly what its purpose is. The thing is, everyone is usually wrong about that. When a schema is first created, it might be simple and clear, but as time goes on it generally accumulates cruft, like temporary tables meant to solve a short term problem but never removed, deprecated tables and views that haven’t been removed because of the hassle of removing a few lingering queries in the code, denormalized views, etc, all of which complicates the schema. One of the most annoying, is a temporary table which was named something like “temp_2009” but was later changed to a permanent part of the database *but still has the temp name because it’s too much hassle to refactor the entire application to use a different one. If one doesn’t already know what’s going on, it can be difficult to parse an old schema.

A simple solution would be to just add documentation strings to SQL. In some programming languages such as Lisp or Smalltalk, one can assign a special strings to any object which explicates that object’s purpose. The strings can be queried at run time so one doesn’t have to dig up the source file to know the purpose of a function, macro, or variable. Why this is not a feature in the SQL standard is beyond me. It would be so simple to store documentation strings in the table which already stores table and schema information in most SQL databases. It would involve literally adding only one column to said tables. Better yet, store documentation strings for tables, views, and optionally for each column of each table. Make the adding of the string part of the table definition:

$ create table foo "This table contains foos" (
    alpha varchar(25) "The first field of a foo",
beta numeric "The second field of a foo"
);
=> Table created.

$ documentation foo
=> "This table contains foos"

And everything is set. We can now specify, in English what a table is used for, and how it’s used, and what part of the application uses it, without future developers having to resort to grepping for everything. Even better, this is programmatically accessible so applications can query an fetch these strings as well, which would be useful for database administration applications or for applications like Cost Point which are little more than a thin interface layered over a database schema. Considering how much support SQL offers for validating data, from types to check constraints, a little bit of high level explanation would seem to make sense. As I already said, why this isn’t already a feature, is beyond me.

Last update: 16/05/2013

The Right/Left Spectrum is a Political Delusion

2013-04-18T00:00:00-04:00

The Right/Left Spectrum is a Political Delusion

The political spectrum across the developed world is often divided along the lines of Right versus Left. This dichotomy dates back to the French Revolution when members of the General Assembly clambering most for change and radical action sat to left of the chamber while those who urged caution sat to the right. Since then, this duality has become part of the standard taxonomy for nearly every political movement.

These days, politicians are either ‘Right-wing,’ ‘Left-wing,’ or more occasionally, ‘Moderate.’ George Bush was right, Obama left. The Tea Party is right wing, while the Green Party is left wing. Anarcho-syndicalists are leftists, while anarcho-capitalists are right-wingers. Everything and everyone is either left or right, liberal or conservative, Bolshevik or Bourgeois, and people fight long hard verbal wars over who belongs in which category.

Yet, it seems to me that these are very poor classifications. At the outset, it beggars belief that all of humanity’s political movements can be classified in one of two categories, or that the same can be charted on a simple unidimensional political spectrum. And, on closer examination, it appears that this is just the case you can’t reasonably classify every politician or political philosophy as either right-wing or left-wing.

For starters, how does one even define these terms? Just looking at what constitutes right vs left and you find that it varies from decade to decade and from country to country. In Europe, laissez-faire markets are considered ‘liberal’ but in the United States, they are ‘conservative.’ The term ‘Right-wing’ in America refers to Republicans in general, but in Germany it’s reserved almost exclusively to Neo-Nazi groups. ‘Conservatives,’ in the United States talk a lot about the US Constitution, while ‘conservatives’ in Spain talk a lot about the monarchy. There’s no consistency. But it’s more than that though. When you really drill the matter down, you find that most issues just don’t fit on a left right spectrum.

Take marriage for example. Recently in this United States there has been a lot fuss over whether homosexual couples should be issued civil marriage licenses. Similar debates have been occurring in other countries as well. In general, those who oppose same-sex marriage are considered right-wing while those who favor it are considered left-wing. The former support traditional marriage norms while the later prefer a more inclusive approach. So far so good, but tell me: How does one classify a supporter of polygamous marriage licenses? On the hand, it’s more inclusive to support it, so one would think that it’s a left wing position. On the other hand, the majority of support for it comes from otherwise right wing, radical Mormon groups. Further, feminists who are classified as left-wing, generally oppose polygamy on the grounds that it is usually at the expense of women. Yet you still can’t classify polygamy as right-wing because it’s certainly outside of the scope of ‘traditional marriage.’ Is this because polygamy is actually a ‘moderate’ position and between the right and left? Or perhaps, is it a radical position outside of the scope of left and right? The later obviously.

And you can apply this approach to other related issues. Bestiality? Group marriage? Abolishing civil marriage? Which of these are strictly right-wing and which are strictly left-wing policies? What about a person who supports same-sex unions, but opposes mixed-race unions? How about the reverse? There is no consistent way to classify all possible positions on marriage on the left right spectrum. The same with economics((If being pro-business and anti-tax is right-wing and being anti-business and pro-tax left-wing, what about a policy that gives businesses tax money for a specific purpose?)) military, social issues, and so forth.

So why are the terms ‘right’ and ‘left’ so widely used? Well, at one point it made more sense. In the 18th and 19th centuries in Europe the Right were those who favored the established order, while the left favored revolution and broad social change of one form or another. Most of Europe was governed by centuries old monarchies and aristocracies at the time and the established gentry were the Right. The Left were those political dissidents clamoring for changes such as representative government, civil liberties, free markets, socialism, nationalism, etc. As such, French Republicans, Italian Unificationists, and Russian Bolsheviks could all be members of the Left, despite the fact that they had little, if anything, in common. At the same time, popes, kings, and magistrates could all be considered part of the right despite the fact that few of them had much in common either.

As time wore on however, left wings movements survived long enough to become the new right wing, and new ideologies formed which became the new left. Many new ideologies became throwbacks to older ideologies, and some ideologies fused both new and old ideas in novel ways. There were some movements which were both restorationist and revolutionary. It got to the point that the old rationale for the terms didn’t apply anymore but people would still apply them to the two largest factions in their respective countries, whatever those factions happened to be because it was easier than inventing new, more descriptive labels. As such ‘right’ and ‘left’ ceased to have any meaning except as labels for regional political factions.

These days, the terms right and left, and in American politics the terms conservative and liberal, have mostly become labels with which to brand political opponents. For example: “The American Right opposes gun proliferation, Hitler was right-wing, therefore gun proliferation is evil like Hitler.” Never mind the fact that the Nazis approach to gun control looked more like the American Left’s and that really, neither the American ‘Left’ nor the American ‘Right’ looks much like Nazism at all. “You’re a right-wing nutcase!” “You’re typical liberal!” These accusations mean next to nothing concretely and are concerned solely with factionalism, which at the end of it all, is a waste of time if you want to understand matters and solve problems.

So anyway, I try not to use them.

Last update: 18/04/2013

My Embedded Music Player and Sound Server

2013-04-10T00:00:00-04:00

My Embedded Music Player and Sound Server

Some months ago, I got a Raspberry Pi in the mail and proceeded to install MPD on it. After a few days playing with an embedded MPD server and figuring out what I liked and didn’t like about the arrangement, I decided on a significantly more elaborate project to build on it. I wanted to be able to control the player, even if all of the computers in the house were off. I also wanted to run player while using my desktop, which I couldn’t really do because they shared the same desktop speakers. I ended up with a list of features for an embedded music system:

MPD installed on a Raspberry Pi with a music library stored on a USB attached hard drive
A Pulseaudio server installed on the Pi with computers in my apartment configured to stream sound to it
A physical control panel attached to the Pi, which displayed player information and let me start/stop, mute/unmute, select songs, and change the volume on the device

The first of the features was already done and had taken all of thirty minutes. The second was not done and would take longer, but was still easy. The last item on this list however, required a bit of physical hacking to do. I ended up using all of the GPIO pins to do it. Anyway, here’s a picture of the final product:

I think it turned out well. That’s a 16x2 LCD display, two RGB LEDs, two rotary encoders, some wires and a circuit board, embedded into a homemade Plexiglas and aluminum frame. Together, they use up all of the GPIO pins on the Raspberry Pi. ((The rotary encoders have built-in press switches.)) Putting that together took quite a while and was a bit of trial and error. The original plan was to whittle a case out of wood but that turned out to be more labor-intensive that I desired while I don’t think that an ‘international-style’ case is as attractive, it still works for my project.

I wrote the initial code in Python, but found out that the current Python GPIO libraries were unsuited to reading rotary encoders. So I rewrote the project in C using the excellent WiringPi library. It actually constitutes my first return to C in a long while. I had to learn both MPD client library and the ALSA library by reading the code.((The ALSA library was by far the easier to figure out because the amixer program was so simple. If you want to write code for ALSA, read the amixer code.)) In retrospect, I should have written it against Pulseaudio rather than ALSA, but I hadn’t decided initially that that was the direction I wanted to go. In the end it didn’t matter because I only change the master volume.

One thing I did learn and had to code for, is that the human ear does not perceive volume change linearly, so I had to convert it logarithmically between display and reading. This is apparently a common practice and is why potentiometers are commonly sold which change logarithmically. I was using a rotary encoder to adjust volume, so I had to do it in software.

The code for all this is, if you want it, on github.

Making the physical control panel was harder in the end than writing the code for it. I started with a prototype on a breadboard against which I wrote the code:

This worked of course and I could have left it at that, but it was unfinished and I had to reach through all the wires to use it. Making the finished device however, turned out harder than I thought it would. I initially started carving wood to make the case but changed my mind after I realized that the finished product would probably be pretty ugly. (My whittling skills are not where I’d like them to be.) So instead I bought some acrylic sheets, broke them into smaller sheets and cut out room for the components to fit using a Dremel tool. It took me three tries to get right.((In retrospect, I could have gotten away with just drilling holes for the rotary encoders and just attaches the LCD and LEDs behind the clear screen. I didn’t think of that at the time.)) I then replicated the circuit on the breadboard on a protoboard which I could connect to the Pi with a 13pin ribbon cable. I was going to put the whole thing, Raspberry Pi and all, together into one bit clear acrylic box, but changed my mind to make the control panel separate and connect it using rivets rather than glue. I wish I could say I did this because it looked better (it does) but I really did it because it was easier.

I now have the mostly finished product. I think it’s pretty neat. Here’s a quick demonstration:

Last update: 10/04/2013

A kind of an alarm clock

2013-03-08T00:00:00-05:00

A kind of an alarm clock

One thing I’ve written about before is the problem of Compulsive Internet Use before. One thing I’ve tried in the past to deal with is was my Shutdown Nag. This, at the time, was a quick extension to my Window Manager which would lock the computer at a preset time and then give me the opportunity to save my work before shutting the computer down for the night. It worked reasonably well, but I’ve since changed the window manager I use from Stumpwm to Xmonad and the old tool no longer works. I’ve since intended to replace it with a similar window manager agnostic tool, but hadn’t the will to actually go through the effort to write it, until now.

My new program, Nighttime-Alert is a quick C program, which I hacked together initially by retooling code from dmenu. Then I skimmed some actually docs on how to use XLib and made it work in the way that I wanted. That way is this:

The program is triggered by cron to start to start at 10:00 PM. (It can be made to start at anytime, but I chose 10:00 PM)
The program locks the keyboard and mouse and flashes a message announcing that the computer will shutdown soon.
I can then press escape to make the message go away and save my work.
The message returns every 3 minutes.
At 10:30 PM, the program locks the keyboard and mouse again and shuts down the computer. (The shutdown time is set with a CLI option in the cron job)

Simple and it keeps me from accidentally browsing the Internet past my (self-imposed) bedtime. Also, it looks kinda cool:

For those who want to try it themselves, it’s on Github and it should be a breeze to compile and run. The only requirements are that it run on a Linux computer running X Windows and systemd, so most of them. ((It can be made to work without systemd trivially, but I haven’t done so. Patches are welcome.))

Last update: 08/03/2013