Tim Loughrist

  • Flatiron school

    I’ve decided to enroll in the Flatiron School’s software engineering program.

    I had initially planned on preparing for this career shift using only free sources, and I still think that would have probably worked out. But working with a formal bootcamp offers several benefits:

    • external accountability, which is not essential but is certainly welcome
    • tied-and-true curriculum
    • career support services

    This last benefit is particularly important. I feel like I cannot afford to operate without the safety net it provides.

    So, I’m currently working through the prework prior to my August 8 start date. So far, so good.

    Resources I’m finding helpful

    The Flatiron School is a well-established and well-respected coding bootcamp providing tracks in software engineering, product design, data science, and cyber-security.

  • Reflection filter

    A warning: do not read this post if you’re currently working on problem set 4 for cs50. Doing so would violate the course’s academic dishonesty policy.

    I ran into an interesting bug while working on a c++ problem set for cs50. The function is supposed to flip a .bmp image horizontally. Here’s my first attempt:

    void reflect(int height, int width, RGBTRIPLE image[height][width])
{
    RGBTRIPLE *buffer = malloc(sizeof(buffer));
    for (int i = 0; i <= height; i++)
    {
        for (int j = 0; j < width - j; j++)
        {
            *buffer = image[i][j];
            image[i][j] = image[i][width - j];
            image[i][width - j] = *buffer;
        }
    }
    free(buffer);
    return;
}

    This worked…almost. Every column of pixels was replaced by its partner from the opposite side of the image except the first column. That one was simply moved up one pixel.

    My hypothesis is that the argument width delivers the total number of columns of pixels, rather than a count of the columns starting with 0. Consequently, my function starts by trying to grab a pixel from beyond the last column.

    This took me a minute to figure out because I would have thought that trying to reach beyond the last column would result in a segmentation error, but apparently it just wraps around to the beginning of the next row. That’s why my first column was simply moving up one pixel. What I found particularly interesting is that it doesn’t result in a segmentation error even from the last row, where it is reaching for a pixel from a row that doesn’t exist. It simply resulted in a black pixel.

    In any case, the solution is straightforward: simply reduce the number of the column you’re reaching for by one.

    void reflect(int height, int width, RGBTRIPLE image[height][width])
{
    RGBTRIPLE *buffer = malloc(sizeof(buffer));
    for (int i = 0; i <= height; i++)
    {
        for (int j = 0; j < width - j; j++)
        {
            *buffer = image[i][j];
            image[i][j] = image[i][width - 1 - j];
            image[i][width - 1 - j] = *buffer;
        }
    }
    free(buffer);
    return;
}

  • Speed bumps

    The third problem-set for cs50 involves writing a recursive function. The basic concept of recursions is clear to me; we worked with recursive definitions in philosophical logic.

    But for some reason, I just could not manage to get my head wrapped around how this particular function had to be written. After several days of returning to the problem again and again I was finally able to get it to do most of what I wanted it to do. There are still some edge cases it isn’t handling right.

    And, hard as it is, I just need to be ok with that. I’ve got a demanding timeline laid out for myself and I need to trust that these things will come to me with time and practice. But leaving the project before I know how to fix the mistakes is killing me.

    Resources I’m finding helpful

    In the introduction to Learn Python the Hard Way , Zed A. Shaw writes:

    While you are studying programming, I’m studying how to play guitar. I practice it every day for at least two hours a day. I play scales, chords, and arpeggios for an hour and then learn music theory, ear training, songs, and anything else I can. Some days I study guitar and music for eight hours because I feel like it and it’s fun. To me repetitive practice is natural and just how to learn something. I know that to get good at anything you have to practice every day, even if I suck that day (which is often) or it’s difficult. Keep trying, and eventually it’ll be easier and fun.

    A useful reminder to me when I’m having a sucky day of coding like today.

  • Hard exit

    I spent some time talking to friends last night about moving out of academia. Originally, my plan was to take a soft exit over the next five years. This conversation convinced me that that wouldn’t be the right move for me. I’m almost 40. That’s not ancient but it’s not young, either. Five years represents a significant portion of my remaining working life. Furthermore, five years is an epoch in the tech world. I simply need to be moving faster than that.

    To that end, I’ve decided on taking a hard exit from academia. I’m giving myself roughly a year to get up to speed and then I’m hitting the job market.

    Resources I’m finding helpful

    This post by Thomas Foerster on transitioning from philosophy to tech has reassured me that making a move in the time frame I’ve given myself is feasible.

  • Deep ending

    My first year in grad school was intense. I had a good, broad foundation in analytic philosophy but I wasn’t ready for a seminar on Kant’s Critique of Pure Reason, a notoriously difficult epistemology course, or the level of the discussion in the graduate student common room.

    I was out of my depth but that was a good thing. Not understanding much of what was going on around me forced me to pay careful attention, to ask lots of questions, to read and read and read. It guaranteed that my philosophical acumen would grow by leaps and bounds.

    I’ve been trying to emulate that experience as I learn to code. Completing cs50 at an accelerated paces is helping, as is listening to podcasts on software development and reading through introductory texts. What I’m looking for now is a way to surround myself with that higher-level conversation, where I can hear and ask about topics I’m not yet familiar with.

    Resources I’m finding helpful

    I’ve been listening to the Software Developers Journey podcast hosted by Timothée Bourguignon. It’s often inspiring and it’s giving me an overview of the different roles that compose the broader profession.

  • Too long watching my feet

    A friend once said that I’ve tended to let the world take me where it will. I can’t deny it. Studying philosophy may not seem like the path of least resistance to most but it certainly seemed that way to me. This is not to say that it was easy going; rather, it simply didn’t require me to forge a new route for myself. I could just look to see what the next step was for people in my position. Apply to grad school? Sure. Take work as an adjunct? No problem. Apply out for tenure-track positions? You got it.

    It’s years later and I find myself in an enviable position: a tenured professor of philosophy. And yet, I’m restless. I’ve kept my head down, my eyes focused on the trail ahead of me for so long, I’ve lost track of the destination. Until recently, I haven’t dared to consider setting off in another direction entirely.

    I entered college prepared to declare a major in computer science. Something dissuaded me, though I don’t quite remember what. I did have a low opinion of my own mathematical and logical skills at the time; perhaps that was it. In any case, I’m preparing to start down that path again. I’m in the process of putting together a course of studies for myself that looks something like this at least to begin with and in very broad outline:

    • Fundamentals of programming, including the basics of C++
    • Java
    • Python

    I’m currently working my way through Harvard’s cs50 via edx. Once I’m done with that, I’m hoping to be in a good position to start teaching myself higher-level languages. I don’t know yet if I’ll end up pursuing a formal degree in computer science (this seems a bit contrary to the whole exercise, honestly), going to a coding boot camp, or just trying to make it on my own using the wealth of resources available to me.

    The goal of this blog is to record my progress on this journey, along with my reflections about it. When I end up creating things I’m proud of, I’ll post those here, too.