Weeks 31-33

Coding Challenges, Job Interviews, and a Trip Home

It’s been almost exactly a month since I returned to NYC from California. However, only now does it feel like I’m really starting to settle into life here. This is largely because I’ve continued to travel over the past several weeks– once for a week-long visit with my family in Missouri and also for weekend trips to various cities where my partner is considering attending graduate school in the fall. Finally now there are no impending trips on the horizon, only lovely visits from other people coming here to look forward to.

After two seemingly endless weeks of submitting job applications with little concretely positive feedback (Weeks 29 & 30), the week before I went home to Missouri I had three in-person technical interviews with companies in NYC. The length and format of the interviews varied from an entire day long, pairing with developers as I would if I were working at the company on a normal day, to a round-table style of 2-hours worth of interviewing with 4 different developers, to a one-hour pair programming with a senior developer, building off of a coding challenge I had previously submitted. Though I was nervous, all of the interview experiences ended up being extremely fun and productive. I learned loads from the developers I was working with, especially those who I paired the entire day with, and it was interesting to get an inside view of several very different tech companies. In each case, once we started working together and I was able to (somewhat) forget about the fact that I was being evaluated for a potential job, it was exciting and fun to get to talk with more people about my code and to work through problems together. I take my enjoyment of these processes as further evidence that I’m pursuing the right thing!

And, I’m excited to share, I’ve accepted a position as a developer apprentice at one of the companies and will start this upcoming Monday. Generously, they were willing to take me on despite the fact that I will more than likely be leaving New York City at the end of the summer, which, understandably, was a deal-breaker in the other two cases. I can’t wait to be a part of a professional software consultancy team, and still feel rather in shock that someone is willing to pay me to do this work. I know it will be challenging, and probably pretty overwhelming for a while (maybe for always?), as I work to pick up their technologies and learn their workflow as thoroughly as I can, but I’m excited and feel ready for this challenge.

As I mentioned in my last post, I don’t have that much code to share from recent weeks, as I think companies would likely frown upon me sharing my solutions to their coding challenges. However, there are a couple general observations I’d like to make about the hours I’ve spent working on such code challenges over the past few weeks, as they’ve seemed largely like a really good use of my time.

1.) It’s good practice to have to interpret coding instructions written in ways, and with vocabulary, that’s unfamiliar. There were several times when I felt confused or overwhelmed when initially reading a challenge description. However, once I slowed down a bit and looked up the unfamiliar phrasing, I realized that they were usually asking for things that I knew how to do, just in different terms. Also, the research that I did in order to better understand the questions often made concepts that I had only somewhat understood before become more clear and concrete. Moreover, I’d never seen an “interface specification” before, and now I feel comfortable with designing a solution to a problem given in such a format.

2.) Unit testing– A few of the challenges required thorough unit testing to accompany my solution. Because I hadn’t ever written tests in JavaScript before, this required me to spend time learning about testing (something that I’ve wanted to do for a long time, but hadn’t prioritized). It turns out that testing is really fun and also makes loads of sense. Refactoring my code has also become a lot more enjoyable since I started to use tests. Note: I haven’t done any front-end testing yet, but I’m looking forward to learning about that too.

Only a couple of code challenges and interviews ended up having hacker-rank style algorithmic questions, but I’ve also spent a fair amount of time in the past few weeks practicing such challenges on the Codewars website. (They’re addicting!) Here’s the link to my GitHub where I’ve been storing some of my solutions: https://github.com/bolducp/codewars, and the link to my profile: http://www.codewars.com/users/pbolduc

I’ve also continued to work on a couple side projects– 1.) building a website for a future alternative high school: https://github.com/bolducp/bristleconePineSchool 2.) a web app that allows users to make book recommendations to other people (I just started this one yesterday, so there’s not much to see yet, but I hope to get it finished before I start work on Monday): https://github.com/bolducp/bookMarkers

Weeks 29 & 30

After returning from California last week, I’ve spent the majority of my time working on job and apprenticeship applications and coding challenges. Some of the challenges have been timed assessments on HackerRank, and others have been longer challenges for which I submitted an entire program. Most of them have stated explicitly that I’m not allowed to share the coding question(s) or my answers, but even for the ones that don’t state so, I imagine the companies wouldn’t want me publishing that information online. Therefore, I don’t have a lot to show in terms of code for the past week and a half. However, once I’ve finished a few more of these applications, I’m going to return to some of the projects I’ve been thinking about, and I’ll share the code I’m writing again then. Also, in the process of working through some of these assessments, I’ve run into some specific technical challenges. I think that my solutions to them might be useful to other people too, and so I’m planning to try to write a couple blog posts about really particular coding techniques/difficulties (e.g. problems that can arise from the fact that the Javascript sort method on an array both returns the sorted array and sorts it in place, and how this can lead to misleading errors).

When I haven’t been working on applications, I’ve been trying to learn more about algorithms and data structures. I’m doing a Stanford Coursera class, Algorithms: Design and Analysis, Part I, and reading through parts of this MIT text, Mathematics for Computer Science. Both of them have been really useful so far.

Week 28

Two Months at a Coding Bootcamp: Reflections

As of this week, I’ve finished two full months at a fully-immersive, live-in bootcamp California. Here are some general thoughts that I have about bootcamps as a result of that experience:

It is a tremendous opportunity to get to be in a place where the entire focus is on learning to code, all day, every day. Though I had made significant progress in my 4 months of self-study before entering Coding House, once arriving, I wrote more (mainly terrible) code than I could have imagined producing in any other environment on my own. Even the physical space of rows of desks and monitors inspires a sense of purpose and drive. If what you’re looking for more than anything else is a community in which to spend as much time coding as possible (70+ hours a week), then for that reason alone, a bootcamp may well be a good fit.

It’s possible to learn many more types of things and in different ways when you are part of a community of learners than it is on your own. I believe that the ability to teach oneself things is a crucial skill, especially in tech. Additionally, though, I think that if you insist too much upon self-reliance in learning, it’s easy to miss out on extremely valuable lessons that challenge your own methodologies and habits, not to mention the fun and reward of collaborating over ideas with other people. I often felt that I was learning nearly as much from talking through problems with my cohort-mates and watching them approach challenges as I did from our instructor.

Rigid structure can be a blessing and a hindrance. During the first four weeks of the bootcamp, I often felt grateful for the strongly structured nature of the lectures, workshops, and homework. We were introduced to technologies or frameworks, given some time to explore for ourselves, worked through some examples as a group, and then assigned progressively challenging projects to implement on our own during the evenings. Especially at the beginning when I was brand new to JavaScript (minus two weeks of pre-work), this made the huge amount of knowledge to learn feel more manageable and my studying feel focused. However, the more comfortable I became with the landscape of technologies and teaching myself new things, this rigorously defined structure in which we were evaluated by how well we fulfilled the MVP (minimum viable product) specifications of each night’s assignment, at times felt like a hindrance. If I could go back, I’d try to care less about getting all of the MVP standards for each project finished if doing so meant that I didn’t thoroughly understand what was happening in each piece of my code.

A focus on learning as many frameworks and libraries as possible in a short amount of time can make it difficult to gain a deep understanding of each piece and how they work together. There’s just not enough time in a few months to learn loads of frameworks and also to understand them deeply. We were introduced to many, many libraries and frameworks, and getting to see the use and power of such tools was exciting and inspiring. However, if your goal is to attain a thorough understanding of any of the frameworks and its underlying theoretical concepts, it is difficult to find time and support to focus your energy in this way. A couple different times, I asked about whether/when we would focus more on best practices and on learning to write maintainable, clean code, and learning to write tests. I was told that “in order to write good code, you first have to write a lot of shitty code.” And this seems true to me– you can’t become good at something without first being bad at it. But as I develop as an engineer, I want to do so in a way that prioritizes best practices as much as possible, not just writing code that works. I plan to take the exciting introductions to these many frameworks that I’ve gained and develop my understanding much more deeply.

Overall

In the end, the two months that I spent at this coding bootcamp doing nothing other than thinking, talking about, and writing code were tremendously productive and inspiring. I learned a huge amount from our instructor, guest lecturers, and my cohort peers, and I’m even more excited about software and web development than I was before. The intensity and focus of a bootcamp environment were a good fit for me. As I move forward with software development as a craft, I hope to find a position at a place where I can take the skills and enthusiasm that I’ve gained and contribute to a meaningful project. I also hope to find a place that will prioritize developing best practice knowledge over quick production, where I can build careful programming habits that I can stand behind.

Week 27

Coding House: Week 7

Today marks the end of the first seven weeks of the Coding House program for our cohort. After a 3-day break, we’ll begin again on Monday in our new role as “code mentors”, essentially teaching assistants for the next batch of Coding House students. I’m really looking forward to meeting all of the incoming students, to having a chance to re-visit the material they’re working on, and to encouraging them as they debug, debug, and debug as I’ve been learning to do over the past two months.

This week was spent largely focused on learning more about user authentication, particularly through using third-party services like Firebase and Stormpath (we had a guest lecturer from Stormpath deliver a 5-hour workshop on Wednesday that was excellent). We’ve also spent some time doing mid-way assessments this week. One was an application challenge– we had 90 minutes to build a to-do app with Angular, and the other was a 3-hour Hacker Rank test today. I really love doing Hacker Rank challenges, and it was fun today to have a full 3 hours to devote to them. Though my initial response to most of the problems is still to reach for a for-loop, I can usually come up with alternative solutions as well with a bit more thought, something that wasn’t possible for me at the beginning of the cohort. The thing that was most enjoyable about today’s test, though, was that I spent the majority of the time refactoring my code and coming up with alternative solutions in order to make it more readable. Though I got all of the test cases to pass within and hour, I kept working for the rest of the time to clean up my code, and I feel pretty pleased with the changes I was able to make.
Here are a couple examples of the transformations:

// One challenge asked for a large multi-digit number to be transformed into a string with "*" characters between two even numbers
// and "-" characters between two odd numbers, considering 0 neither even nor odd

// my original solution works but is nearly impossible to understand

function weirdNumSplitter(num) {
    var numArray = String(num).split('');
    var weirdString = '';

    for (var index in numArray){
        if (parseInt(numArray[index]) === 0){
            weirdString += numArray[index];
        } else if (parseInt(numArray[index]) % 2 === 0 && parseInt(numArray[index -1]) % 2 === 0 && parseInt(numArray[index -1]) !== 0) {
            weirdString += '*' + numArray[index];
        } else if (parseInt(numArray[index]) % 2 === 1 && parseInt(numArray[index -1]) % 2 === 1 && parseInt(numArray[index -1]) !== 0) {
            weirdString += '-' + numArray[index];
        } else {
            weirdString += numArray[index];
        }
    }
    return weirdString;
}

// And here's the refactored version:

function weirdNumSplitter(num) {
    var numArray = String(num).split('');
    var weirdString = '';

    for (var index in numArray){
        var currentNum = parseInt(numArray[index]);
        var prevNum = parseInt(numArray[index - 1]);
        var currentIsEven = (currentNum % 2 === 0);
        var prevIsEven =  (prevNum % 2 === 0);

        if (currentIsEven && prevIsEven && prevNum !== 0 && currentNum !== 0) {
            weirdString += '*' + currentNum;

        } else if (!currentIsEven && prevNum % 2 === 1) {
            weirdString += '-' + currentNum;

        } else {
            weirdString += currentNum;
        }
    }
    return weirdString;
}

// I also wrote this again using a map, just to try another approach:

function weirdNumSplitter(num) {
    var numArray = String(num).split('');
    var weirdString = numArray.map(changeChar).join('');

    function changeChar(char, index) {
        var currentNum = parseInt(char);
        var prevNum = parseInt(numArray[index - 1]);
        var currentIsEven = (currentNum % 2 === 0);
        var prevIsEven =  (prevNum % 2 === 0);

        if (currentIsEven && prevIsEven && prevNum !== 0 && currentNum !== 0) {
            return '*' + currentNum;

        } else if (!currentIsEven && prevNum % 2 === 1) {
            return '-' + currentNum;

        } else {
            return currentNum;
        }
    }

    return weirdString;
}

Week 7 projects/coding assessment:

Firebase chatroom app:
on github: https://github.com/bolducp/angularFirebaseChatroom
live on gh-pages: http://bolducp.github.io/angularFirebaseChatroom/#/

90-minute coding assessment (build a MEAN stack to-do app)
on github: https://github.com/bolducp/toToAppCodingTest
live on heroku: https://polar-ravine-30366.herokuapp.com/#/

Week 7, Main Topics:

  • More Angular JS
  • custom form validation with Angular
  • Angular Fire
    • realtime database storage
    • chatroom functionality
    • user authentication
  • NPM packages
    • bcrypt-node
  • user authentication using headers
  • web scrapping
  • Stormpath

Week 26

Coding House: Week 6

The main focus of learning this week has been AngularJS— the final piece of our MEAN-stack puzzle. Angular is a framework that enables one to write fast single page applications, connecting the HTML and JavaScript code in a unique way. I’m still wrestling with figuring out how all of the front-end and back-end components of our Express apps work now that we’ve thrown Angular into the mix. But the possibilities enabled by data-binding and templating are already apparent and exciting. For example, a filtering function that took me 15 lines of jQuery and JavaScript to write before can be written with just two small editions to the HTML now.

Another prominent and exciting aspect of this week was attending the ForwardJS tech conference in San Francisco on Wednesday. It was an all-day conference with dozens of lectures on various aspects of JavaScript and web development in general. Though many portions of the talks I attended were too advanced for me to follow, it was thrilling and still very informative to listen to many people who are passionate and thoughtful about writing code.
Forward JS Conference Website

Week 6 projects:

on github (pair-programmed): https://github.com/bolducp/Squirrel-Seeks-Chipmunk
live on heroku: https://evening-reaches-83052.herokuapp.com

on github: https://github.com/bolducp/angularStockTracker
live on gh-pages: http://bolducp.github.io/angularStockTracker/#/

on github: https://github.com/bolducp/angularContactList
live on gh-pages: http://bolducp.github.io/angularContactList/

Week 6, Main Topics:

  • MVC paradigm
  • Angular JS
    • data-binding
    • Angular expressions
    • directives
    • controllers
    • dependency injection
    • ng-storage addon
    • services and factories
    • front-end routing (ui-router)
    • state
    • partials
    • satellizer for user auth on the front-end
    • custom directives
  • NPM packages
    • q library
  • promises
  • more Gulp
  • bundling and minification
  • source maps