Owen Schandle

As this static, Web 1.0 nonsense clearly demonstrates, I am not a web developer. You should be happy there's even any CSS. Here, though, are some things that I am interested in:

Photography

I like taking pictures, but I don't feel like any strong philosophy guides my work. I like using primes for the aperture, the image quality, and how consistent use helps you to start considering your framing before you even bring the viewfinder up. Walk around with different primes and you see different things. These days cell phones dominate my metadata.

I like Nikon. I like Lightroom.

Buy used lenses. Visit my Flickr.

Software Development

I've always liked computers. When I was a kid I learned the basics of C, wrote stupid games for the TI-89, and spent a massive amount of time playing Mystical MUD.

Most of my professional life has been spent developing C++ desktop applications, doing basic sysadmin work, and writing scripts to automate a variety of things. Often I have some spare cycles for contract work in this area, so reach out if you're interested.

Here is my Github. There's not much on it, but my dotfiles are there to critique, and I recently wrote a Qt application designed to visualize and gather statistics about how many counties in the United States you've visited.

Here are some of my firm philosophical positions, in no particular order:

Defining contracts. The expectations of any piece of code should be able to be understood without comment. Asserts. Const correctness. These days, can this be constexpr?
Speaking of comments, I use them to break up functions into sections and to document things that should be changed. Outside of this, only especially complicated logic should have comments -- strive to write code that is readable without comments.
Your commit log should explain why, not what. I can look at the diff and see what the commit did. I should be able to look at a comment explaining what a particularly complex bit of code does if I'm trying to understand the what. I am looking back at the history of this function because I want to understand why some decision was made; what the intention of this API was, et cetera.
Clarity over brevity. Only use auto for things like `auto* p = new LongClassName<Template>();` Or the result of std::find. Things like that. Don't you dare `auto f = function_call();` me. C++ is a strongly typed language for a reason.
west const is the only acceptable choice.
Clarity over optimization. Premature optimization yields unreadable (and thus unmaintainable) code. Save structure packing, (non-automatic) cache optimization, and whatnot for code that actually needs to be fast.
With the above said, don't make ridiculous decisions. Use std::unordered_map unless your map needs to always be sorted. Profile things as a matter of course -- if you're writing some class that is meant to support 1000 things... profile how it behaves supporting 100,000 things. Find your stupid mistakes.
Compile and run the tests with sanitizers.
Test-driven development isn't a necessity, but it's a good idea.
Outsource to third party libraries whenever possible. The chances are quite low you are going to write a better library for some common protocol in which you are not an expert. For C++, conan is great. Keep those libraries up-to-date as a matter of course.
Aside from the perennial "what should this be named?" discussion, nothing spends more time than discussion during code reviews about code style. Eliminate that time completely and enforce a clang-format file on your codebase. It doesn't even matter what the format is, just pick something. That way if you want to see it differently, have checkout and commit hooks that format it the way you'd like.
Stop doing things and running services as root. It shocks me how often I still see people wrecking permissions and risking exploitation with this.
Standardize the build environment. Docker, configuration management, anything you need to do so that there aren't errors that only happen on the build system.
Use vim. Eight megabytes and constantly swapping!

Here is a haiku I wrote that in no way reflects my perpetual experience with memory management:

Memory access
Then, something unexpected
Segmentation Fault

Frequently Asked Questions

Why aren't these sections different pages?
Why aren't there answers?

    -----BEGIN GEEK CODE BLOCK-----
    Version: 3.1
    GCS d- s+: a C++ UL++ P++$ L+++ E--- W++ N+ o--? K? w++ !O-- M+ V? PS+ PE
    !Y PGP+ t++ 5- X R tv+ b+ DI++ D--- G e++ h---- r+++ y++++
    ------END GEEK CODE BLOCK------