As I mentioned earlier, I noticed a few things during my wedding planning process that I thought were worth sharing now that all is said and done on that front. While I mentioned having a Google Drive spreadsheet in my last post, I wanted to discuss it some more because we managed to get some neat uses out of it that are worth documenting and reusing. Continue reading »
Whodunnit has been my guilty pleasure show all summer. It had a cool premise, 12 “guests” went to a mansion to play a murder mystery game, only to find a guest “murdered,” and be told that 1 of them is the “killer” (obviously a TV show isn’t going to actually kill people, but if you suspend the disbelief, it was a fascinating concept). It was reminiscent of another “reality” show that was also a guilty pleasure of mine, Murder in Small Town X (same basic idea, except the suspects were all a separate group of actors and not the contestants). The finale just aired not long ago, and when it was all said and done…my wife and I spent a solid hour and a half, ranting, raving, and coming up with a better version of that type of show.
Having just gotten married recently, I tried a lot of stuff to help make the planning process easier, and had a few thoughts on things that did (and didn’t quite) work that I wanted to share. The first thing I wanted to mention were thoughts about planning and organization. As it turns out, wedding planning isn’t just a 1-person process, and so some degree of organization and coordination winds up being needed. Continue reading »
One thing I’ve noticed the more I work on anything is that reusability is everything. Even if you’re slapping together some simple little script that is intended for 1 specific thing to do some piddly little task, odds are you’re going to need to dig it back out and adapt or convert it for something else. In short, you’re always going to need it. So what does this mean to you as you write any sort of code? Continue reading »
I have to be honest, I’ve never understood part of “soft” deletes that makes it a good idea. You know the basic gist, labeling an action “delete”, and removing it from display, but behind the scenes all you’re really doing is flipping a bit somewhere to tell your application to never show this thing again, as opposed to actually removing it. I suppose it makes sense for when you absolutely, positively, need to retain data (auditing purposes, court orders, etc.), but as far as a general practices go, “delete” should mean “delete”, not “please just don’t show it to me again”.
Continue reading »
For everything we’ve learned about how to make good software, there’s still some pretty glaring failures out in the world that aren’t so much technical failures as they are somebody either choosing to make a bad feature that they should know better than to do, or just not fixing something that people should have realized was a bad idea and fixed long ago. Regardless, here’s a list of things that should be left to die out in the name of making the planet a better place to live. Continue reading »
Recently, I was looking what it would take to notify a Zabbix server whenever an error is encountered in a Python web server. Ultimately (before I realized that Zabbix has log monitoring and that we weren’t going to be installing a Zabbix agent on the server), we went with Zabbix’s log monitoring, but before that I started looking at sending the notification directly from the Python code itself. The quick and dirty lesson here is to thoroughly research the features of monitoring servers (and discuss them with your system admins) before writing code to solve a problem you don’t actually have. The other lesson is here’s how I learned to send notifications directly to Zabbix servers directly from your Python code. Continue reading »
Not a lot of useful, thought out content this time (like every time really, but that’s another point), just a few quick things that I’ve run into over the past few weeks that are worth noting for future reference. Continue reading »
I love software, and I love writing software, but these days there seems to be a belief amongst developers that software and good programming can solve all humanity’s problems. Don’t get me wrong, software can solve a lot of problems, especially problems that involve keeping track of a lot of stuff, tasks very repetitive, and doing lots of math. However, as good as software is, some problems are systemic, people problems, and no clever coding can make that disappear.
All developers have been in this situation, sitting around, staring at the monitor, trying to make sense of the code staring us back. It’s a tough, miserable period for developers going through this. Specifically, it’s a tough, miserable period for developers that doesn’t have to happen. No matter what the code that does this to you, there’s 1 common, glaring thing in common with the code that does this to developers – there are hardly any, if any at all, comments in the code. In the interest of sparing developers this pain, here are some simple rules about commenting that will reduce developer suffering whenever somebody has to read your code. Continue reading »