March – A Retrospective

Think Fast – It’s a language you haven’t used in at least three years

The interviewer was kind enough to allow us to pretend that I remembered how to do string interpolation in python because I at least knew what I wanted to do and that there was a method to do it, and this is not entirely a test of how fast I can get through the Python documentation.

I was glad at least that I’ve heard of a lambda before even if I don’t use them a lot. I tend to prefer named functions simply because as a newer programmer, it’s really nice if automatic errors are labelled with the name of the function that raised the exception instead of going to a line of code and evaluating all the tasks in your head to see where things went wrong.

Performance Considerations

Honestly, the biggest performance consideration (how do you handle gathering insights across an increasingly large dataset that constantly needs to be indexed) is a ‘solved problem’. Yeah, I’m sticking with my comfort zone to crib how Splunk does it but on the other hand, they have a tool that can sort and search multiple terabytes of data in seconds. To be honest, I’m just not that interested in reinventing this particular wheel at this time. It’s a little advanced for my skillset and I’d like to do some more learning and growing before going toe to toe with Big Data greats.

I did have some experience using an API in Python, though

While not shown here, I did have some Python program code left over from an initiative that I tried to get going at a previous employer. The interviewer was impressed that I had identified a common pain point facing the clientbase – which was that as the clients were a largely on-premises deployment strategy, they were vulnerable to losing access to their patient data in the event their main office lost power. Their main office could lose power for a variety of common reasons like a tree hitting a power line, but there are major storm seasons that hit various regions of the US every year. This is a regular and predictable event. So what I had done was I had obtained a then-available free-tier API key to Wunderground, and had it cross reference the clients I was responsible for with whether they were currently under a serious weather-related event. Then I could proactively alert clients to do things like print off schedules and patient contact information, ensure that their generator had fuel if they had one, that kind of thing. For the lifetime of this tool there was a period of time where my clients were able to be more responsive to weather events. Because my immediate supervisor didn’t see the value in this, when Wunderground retired their free tier on their API the wider clientbase never got this protection, and the clients who got hit by the Texas snowstorm the following year were far less prepared than they could have been.
The interviewer loved it, and I was really excited for how things were going and was confident that I could re-learn and surpass my previous Python knowledge.

from stream import streams

changelog = []


def frontend_read():
    print(changelog3)


def main():
    global changelog
    global changelog3
    # Each stream is going to return logs in sorted timestamp order.
    # Merge these sorted streams into a single sorted stream in the var `changelog`.

    # Assume `changelog` has a .read() method attached which the Frontend can
    # use to display the Changelog to the end user. We'll just call print to simulate
    # what the end-user will see.

    # The user will want to see a "timestamp", "integration", and "message" for each log.
    # Logs should be sorted in reverse chronological order.

    okta = streams[0]
    goog = streams[1]
    jamf = streams[2]

    while len(changelog) < 10:
        # the first way I want to attack this is here: each integration value is aware of where it came from and this is where they are concentrated before being used
        m1 = next(okta)  # . + "okta" (.append())
        m2 = next(goog)
        m3 = next(jamf)

        changelog.extend([m1, m2, m3])
        # sorting the changelog - https://stackoverflow.com/questions/18563680/how-to-sort-a-2d-list Considering using a lambda to access the first element in each element to use as the sorting value
        changelog3 = sorted(changelog, reverse=True, key=lambda l: l[0])
    frontend_read()


main()

#stream.py

from random import randint, choice

random_logs = [
  "User created", "User given app access", "User removed app access",
  "User added to group", "User removed from group", "Group created",
  "App created"
]


def _event_stream(start, low, high):
  timestamp = start
  i = 0
  while True:
    i += 1
    timestamp += randint(low, high)
    yield (timestamp, choice(random_logs))


streams = [
  _event_stream(0, 0, 1),
  _event_stream(0, 0, 10),
  _event_stream(0, 2, 5)
]

/**
Implement a restaurant waitlist data structure. It should support the following features:
A party of customers can join the waitlist.
    - one or more
  - the party size is then static
A previously joined party can leave the waitlist at any time.
The restaurant serves the first party whose size fits the empty table size at a time (a table size is given as an argument).
    - tables being stored is handled by another function
**/

//store waiting parties

// remove parties - either customer initiated or because they're beings served


const waitingList[];
// array of objects
//[n] = {name: string , partySize: int}

waitingList.push({ name: "suyog", partySize: 4 });

function joinWaitingList(name, partySize) {
    newParty = { name: name, partySize: partySize }
    //mutate the global array so that everyone has access to the new waiting list
    waitingList.push(newParty)
}

function customerRemoveFromWaitingList(name) {
    /*
    - loop over array
    - find value associated with key 'name' of selected element
    - slice this element from the array or return error if name not found
    - waitingList array no longer has name's party 
    */


    //party is the value of the selected element
    waitingList.forEach((party, index) => {
        if (party.name === name) {
            waitingList.splice(index, 1);
        }
    })

}

function serveCustomer(tableSize) {

    findParty = waitingList.forEach((element, index) => {
        if (element.partySize <= tableSize) {
            waitingList.splice(index, 1);
            return element.name;
        }
    })


}

Interview 2

This one I struggled with as well, but again the interviewer was willing to let me pretend I remembered how to do interpolation because I knew where and what I wanted to do. But because I tripped up on that, I then proceeded to forget variable definitions throughout the space as I let my nerves get to me.

My Friend The Senior Software Engineer looked at it as well

Long Documentation vs Code

Friend: It’s generally not helpful to document how code is doing something. that makes reading the documentation the same as reading the code. it’s more helpful to summarize what the intent of the code is. ideally as briefly as possible. ideally in the function name

Comments are mostly useful if you need to clarify some Arcane Bullshit

Like, # we need to call so-and-so function even though it doesn’t seem to do anything because it actually secretly initializes this undocumented dependency

I’m not sure how much of this is really a problem. Sure, there’s a lot to be said for “the code should be self documenting”, but the need of a junior engineer is different from the need of someone who is far more familiar with the institutional knowledge and the reason why certain decisions were made. In the case of a live technical interview, my view has always been that it is a great strategy to write down the method that will be used to achieve the prompted goal. That way the interviewer immediately gains insight into your problem solving style. One can reference it if they get nerves or lose track, or show how as they get into the problem their proposed solution changes to better fit the need.

Performance Considerations

• The interviewer mentioned that it would be better for an applicant to have some understanding of what the O notation is of their proposed approach

Friend: like seriously “big o” is so tiresome. saying “o value” is like saying “flywheel pattern”, “first order normalization”, or “a monad is a monoid in the category of endofunctors” . it just makes something really simple sound really complicated.

I don’t disagree here, but there’s a middle ground between having low sense of the performance capability of a proposed solution and an advanced sense of performance considerations.