He saw an evening when he sat slumped across his desk in that office.

It was late and his staff had left; so he could lie there alone, unwitnessed. He was tired. It was as if he had run a race against his own body, and all the exhaustion of years, which he had refused to acknowledge, had caught him at once and flattened him against the desk top. He felt nothing, except the desire not to move. He did not have the strength to feel—not even to suffer. He had burned everything there was to burn within him; he had scattered so many sparks to start so many things— and he wondered whether someone could give him now the spark he needed, now when he felt unable ever to rise again. He asked himself who had started him and kept him going. Then he raised his head.

Slowly, with the greatest effort of his life, he made his body rise until he was able to sit upright with only one hand pressed to the desk and a trembling arm to support him.

He never asked that question again.

Put the damn phone down and call them back. Or wait until you’re off the phone to get on the elevator.

Engineering is another story entirely.  Turns out, the things you learn just keep building on what came before — and you actually need those old tomes as you keep moving forward.  This weekend, for example, I’m having to re-acquaint myself with the concept of moments of inertia for an upcoming Fluid Mechanics test.  I’ve had to crack no fewer than three previous textbooks — Dynamics, Statics and Calculus — not one of which has anything to do explicitly with fluids.

There’s something very satisfying about knowing that the material you work so hard on during the semester actually matters.  And it’s why I do try to understand the material at a fundamental level, rather than just memorizing a few formulae or problem-solving techniques.  It’s comforting to know that the effort I spend trying to wrap my brain around these things actually makes me a better engineer.

I open up OneNote, running on Windows 7, under Parallels 6.  That projection instantly drops to 2:17.

I understand a performance hit, but man, that is steep.

But, being the perpetually ambitious sort, I decided that getting the degree wasn’t going to be nearly good enough; I had to get in and out with excellent grades — and in record time.  I immediately wanted to know just how long this was going to take and if there was any possible way to compress it down further.

I dove into the degree plan and the department-provided “flowchart” (more a stack of rectangular boxes labeled with course names than a logical, visual sequence illustrating the relationships between the courses).  It took a good while, but I ended up with the bottom line:

Assuming that all the department’s registration rules had to be followed to the letter (i.e., respecting all the prerequisites, not taking certain classes concurrently, etc.), there was no way to complete the courses I needed to complete in any less than six semesters.  Bending one of those rules (the only one that would ever be bent), I could do it in five.

It was December.  I was to start classes again in January.  Staying in school full-time, taking full loads every semester, including summers, that meant that there was a chance that I could get out in two years.  Two years isn’t that long, not in the long-term view of things — and that long-term view was exactly the frame of reference I’d used in making this decision in the first place.

But it wasn’t going to be that easy.

To be continued.

Having good manners is really just about one thing: being mindful of the fact that you live in a society.  You don’t just barrel through our common space as if you’re the only person who matters; you hold open doors, you smile, you help each other out.  You chew with your mouth closed so no one else has to see or hear you eat; you keep quiet in the library and in the classroom so you don’t disturb the other people who are also trying to get work done; you pay attention to what’s going on around you and you don’t get in other people’s way.

The mannerless kids are rude, self-absorbed and oblivious to their surroundings.  Their numbers seem to be growing, and it’s taking a toll.

I don’t have a single class that isn’t accompanied by a constant din of murmuring.  Sometimes it’s fine; it’s an occasional, brief whisper — but most of the time, it’s several pockets of kids who are just showing up to class, not paying attention, and just talking to each other throughout.  I really don’t get it.  These are mid-level Engineering classes, and none of them is easy.  Either they’re so smart that they don’t need to sit in on lecture (in which case, why come at all?) or they’re idiots who don’t have any interest in paying attention anyway (then, again, why come at all?)

I believe that people should be free to do as they choose (as misguided as many people’s decisions are).  But that comes with one great caveat: you don’t have the right to drag others down with you.  When you talk during class, you’re polluting the space with your irrelevant, distracting conversation.  You make it harder for everyone else to hear what’s going on.  You make it just a little bit harder for everyone else to understand.

It’s not unusual for some of these guys to talk more or less non-stop throughout an entire class.  But last Friday was a new one for me.  As my Materials professor began her lecture, I heard the guy sitting behind me in his usual low-but-not-low-enough voice:

“Yeah… uh-huh… yeah.  Yeah, I think that works… Yeah.  Well I don’t know if I’m going to be able to make it if we do it Wednesday.  Okay.”  It wasn’t obvious which of  his friends he was talking to.  I turned around.  He was talking on his cell phone.

Guy, if there’s something so important that you can’t wait 50 minutes to discuss it, go outside.

Today that same row of kids spent the entire class talking throughout.  And to add to it, they rustled and crunched their way through a box of Froot Loops that they were passing around.

When I left that same class today, two guys were standing in the hallway, shoulder to shoulder, separated by about a foot, talking to each other (but facing the same way), positioned exactly in the middle of the hall so that you just couldn’t pass.  As I got closer to them, they didn’t slide over or step aside; they didn’t adjust.  They just stayed standing right there, looking right at me, but past me, oblivious to the fact that they’ve made themselves a roadblock.  Clueless, uncouth, unmannered.

This kind of stuff goes on constantly.   It gets under my skin more than anything else.  If it keeps up, I may have to start being That Guy and tell these kids that they’re being rude.  If the professor does nothing about it in her classroom, who will?  And who could possibly be expected to do it elsewhere?

I have a WordPress codebase that is shared between three domains. The code executes the same on all three domains — only the domain itself is different. Which, there should be nothing inherently problematic about doing this.

Problem is, when you set up your blog’s settings, WordPress requires that you enter a fully-qualified absolute URL for the blog’s root directory — and that URL is inserted throughout every nook and cranny of the app. For whatever reason, you can’t supply it a domain-less path, even though it seems like this would be a perfectly reasonable thing to expect. (I read one explanation that this would be too problematic for many users.) There are way too many references to this absolute URL to fix by hand, and if it can be avoided, it’s not generally a good idea to go monkeying around in the guts of the app to try to change its behavior. Maintenance becomes a lot more hands-on. Upgrading can easily become a migraine.

So: database hacks to the rescue.

You can actually force WordPress to use a domain-less root path, by altering two settings directly in the database. In the wp_options table, change the siteurl and home values to whatever URL you like. Like, say, the perfectly reasonable / or /blog. The only downside is that if you ever try to change anything on the General Settings page from within wp-admin, WordPress will bark at you and give you a couple of error messages. It’s okay. You can ignore them. Everything else works just fine.

Update: Apparently, everything else does not work just fine. Setting the URL in the database broke Akismet.

Akismet requires the home value in the database options to be the URL associated with your API key. Unsurprisingly, if it doesn’t have that URL, the service requests will fail.

WordPress is great and all, but like every other off-the-shelf software package, there are times where if you want to customize it and color outside the lines they’ve drawn for you, you end up diving down a frustrating rabbit hole.

I’m sure I’ll port this bad boy over to Django soon enough. Then: sweet, satisfying, complete control.

This was the helpful start. I adapted the instructions to create self-contained backup scripts — one each for mysql and postgres — which can be called on-demand or nightly in crontab. The scripts get a list of the available databases and iterate through, creating a single dump file for each database. The contents are then committed to git and then pushed to the remote backup site.

Done.

When I wrote my first Jinja2-based app a couple of years ago, I did so using a little helper script I cobbled together from various Jinja2/Django-type pioneers, and the result was a workable — if a little hacky and kludgy — module that I could reuse in each of my apps. I import it in my views.py, and it gives me the most basic template-type methods like render_to_response and such. It’s limited, but I really haven’t had need for much else. (And when I’ve needed to expand its functionality, I have.) But it’s always felt like a temporary fix — a little incomplete and hackish. I took a look around recently to see if there were any other solutions that integrated Jinja2 into Django a little more gracefully and completely.

It wasn’t long before I found coffin — a library that’s more or less a port of Django’s template functionality, but using Jinja2′s rendering. Its real killer feature, IMO, is how easy it is to use Django template tags and filters within coffin — which is something you might not expect to need, but it’s very handy to have. For example, coffin includes a ton of useful tags and filters out of the box — like the super-useful {% spaceless %}. And you can easily add others, without having to write a complete port.

Coffin works a lot like my little helper module. You import it in every page, explicitly.

But I found something that I think is just a tad better: this fork of coffin. Its best feature is that it can be plugged in directly to Django’s native template loading system, so that it is integrated a little more neatly. All it takes is just a little adjustment to your project’s settings file:


TEMPLATE_LOADERS = (
'coffin.template.loaders.Loader',
)

JINJA2_TEMPLATE_LOADERS = (
'django.template.loaders.app_directories.Loader',
'django.template.loaders.filesystem.Loader',
)


The coffin template handling is enabled more or less transparently — using Django’s syntax while the templates are handled behind the scenes. Thus, in your apps, instead of this:

from coffin.shortcuts import render_to_response

You can use the usual Django syntax:

from django.shortcuts import render_to_response

Helpfully, this fork also allows you to turn off Jinja2 rendering on an app-by-app basis, with a simple tuple in your settings file. So it’s easy to have, say, the Django debug toolbar running with Django templates alongside your app that uses Jinja2 templates.

I really like this approach, mainly for the reason that enabling Jinja2 can be enabled — and overridden — completely from the settings file.

I don’t have a strong opinion about the pros and cons of these two approaches, but I’ll be trying out the template-loader fork of coffin to see how well it runs and how easy it is to use. I’ll be curious to see if anyone has any input as to whether the template-loader approach has any design concerns that I haven’t considered.

Meanwhile, give it a shot! Enjoy.