When I came to Carleton, I had never learned any coding other than the most basic level of an introduction. I ended up taking a baseline CS class my first term completely by accident, foregoing a class I was waitlisted to because CS seemed way more fun. I was very correct in that assumption, and I found out that the logic involved in coding came relatively easy to me. I had tons of fun over those 10 weeks, and I learned a whole lot about coding. However, in terms of my familiarity with computers and technology, I didn’t really learn much other than the inner workings of the software that I was already quite competent with. For this reason, I support Evan Donahue’s assertion that students of the humanities do not need to learn to code to immerse themselves in the world of Computer Science and consequently the Digital Humanities, though I would encourage anyone and everyone to learn to code anyway.

Donahue’s argument is in response to a piece written by Matthew G. Kirschenbaum, who explains why he believes that all humanities students should learn to code. One of Kirschenbaum’s most relevant points is that “programming is about choices and constraints, and about how you choose to model some select slice of the world around you in the formal environment of a computer”, and thus coding gives humanities students a fantastic platform in which to display their perceptions of the world around them. This is certainly a great point. However, Donahue suggests that coding knowledge is undoubtedly not a prerequisite for humanities students engaging with computers, explaining that “in many cases the concerns of the computer sciences and the concerns of the humanities are literally one and the same”, and thus bridging the gap between them is not truly a difficult endeavor. I agree with this thought, as even though I can use a more “ground-up” approach in computer work having learned to code, I could almost certainly accomplish similar goals in many Digital Humanities projects without a knowledge of coding using various programs and software. I would almost say that using preconstructed software actually takes a lot of time and effort out of the equation, though there is clearly a tradeoff when it comes to customizability and originality.

As an example, consider the following:  for my final in the first-term CS class, I created a snake program. That program had roughly 450 lines of code, including the following:

while 0 <= x < x_max and 0 <= y < y_max:
        #The sleep time is split into 4 increments so that the computer
        #can check for multiple commands from the user during the break
        #in movement. This becomes irrelevant as the sleep time becomes
        #shorter but it is important for fluidity in the early stages.
        command_list = []
        time.sleep(sleep * 0.25)
        command_list.append(window.checkKey())
        time.sleep(sleep * 0.25)
        command_list.append(window.checkKey())
        time.sleep(sleep * 0.25)
        command_list.append(window.checkKey())
        time.sleep(sleep * 0.25)
        command_list.append(window.checkKey())

        #Read command list and determine current user command as
        #well as a possible preemptive command. If user gave a
        #preemptive command on the last pass of the loop, assign
        #it as the current direction.
        received_input = False
        if preemptive_command == True:
            user_direction = stored_direction
            preemptive_command = False
            received_input = True
        for command in command_list:
            if command in possible_commands:
                if received_input == False:
                    user_direction = command
                    received_input = True
                else:
                    preemptive_command = True
                    stored_direction = command
            elif command == "p" or command == "space":
                #Pause game
                pause_menu(window)
        #If the user has not given a command, repeat the
        #most recent movement
        if received_input == False:
            user_direction = previous_key

        #Evaluate user control
        if user_direction == "w" or user_direction == "Up":
            #Prevent regressive movement
            if previous_key != "s" and previous_key != "Down":
                y = y - 50
                #Keep track of most recent direction
                previous_key = user_direction
            else:
                #Keep moving in same direction
                y = y + 50
        elif user_direction == "s" or user_direction == "Down":
            if previous_key != "w" and previous_key != "Up":
                y = y + 50
                previous_key = user_direction
            else:
                y = y - 50
        elif user_direction == "a" or user_direction == "Left":
            if previous_key != "d" and previous_key != "Right":
                x = x - 50
                previous_key = user_direction
            else:
                x = x + 50
        elif user_direction == "d" or user_direction == "Right":
            if previous_key != "a" and previous_key != "Left":
                x = x + 50
                previous_key = user_direction
            else:
                x = x - 50

        #Make sure user has not lost the game before moving the snake
        if not 0 <= x < x_max or not 0 <= y < y_max:
            break

This portion of the code was simply a method to take in user input to move the snake. Meanwhile, using a program like Flowlab would give users a way to build a snake game with way less effort and no legitimate coding knowledge, as long as the user is fairly technologically able. Nonetheless, this software would certainly give less customizability, which is clear for example in the section of my code where the program checks for a second input before movement and takes it into account for the following movement.

Thus, overall, I think learning to code is always a great idea and will certainly help with true customization, but it is not a necessary prerequisite for humanities students to engage with the computer sciences and the digital humanities, especially if they are already very competent with computers without coding knowledge.