Forem: Aaroh Mankad

How Do You Conduct A Mock Interview?

Aaroh Mankad — Fri, 09 Feb 2018 02:38:59 +0000

I've recently been conducting several mock interviews for my friends in college, and I want your tips/experience at conducting mocks.

Typically, my flow works something like:

Let them book a time on my Meetingbird Calendar
Depending on the request, set location as whiteboard room, my phone number, or a coderpad link.
I try to do research on the specific company and position they're applying for, to try to compile some questions that they could expect.
During most mocks, I conduct the interview as if it were real, and coach them after we've been going back and forth for some time. This could be things they did really well, things they could have done better, etc.
If they're up for it, I also critique their resumes and do a quick question/answer about the content.
Always make a reminder to wish them good luck on the day of their interview!

Is there anything else I should be doing, or do you have tips on conducting a mock interview? I'd love to hear them!

Contributing to Open Source

Aaroh Mankad — Sun, 21 Jan 2018 19:08:05 +0000

Note: This article was initially published on my Medium account. Follow me @aarohmankad to be the first the read my posts, and feel free to read some of my other articles!

I was recently invited to speak at Github Field Day LA on a topic of my choice. As Github was the main sponsor of the event, I thought I would give a talk on my experience in the overarching Open Source Community, and how/why to get started with making contributions to Open Source projects.

For a video of the talk with slides, scroll to the bottom!

Some (optional) background: Github Field Day is a regional unconference for leaders of technical student communities. Github Field Day LA had student leaders from UCLA, USC, Caltech, UCR, Cal Poly Pomona, and many other campuses in the Southern California region.

The goal of my talk was to convince these leaders to adopt the mindset of contributing to Open Source and then teaching the students at their schools how to do the same.

Why should I contribute to Open Source?

So you’ve heard of Open Source projects, but always thought they weren’t approachable. Or maybe you thought that it wouldn’t be beneficial to you at your skill level. However, Open Source can help you advance yourself technically and professionally. Here are some of the main ways that contributing to Open Source can help you develop yourself:

Open Source Can Develop Your Skills

Whether you’re learning a new technology or you’ve been using it for ages, there are Open Source projects looking for someone of your skill level!
By contributing to an Open Source project, you are learning how a technology is used in industry. You also get the valuable side effect of getting acclimated to large, robust codebases!

Open Source Can Count As Experience

You may wonder: why would contributing to an Open Source project count as work experience? You’re not employed by the company hosting the project, and you’re not getting paid for it.

However, by contributing to a companies open source project, you are required to perform at the bar that the company holds its employees against. This means that there is very little separating you from the engineers that are employed and getting paid for their contributions! This transitions very effectively into the next point.

Open Source Can Help You Network

As I explained earlier, contributing to an Open Source project can count as valuable work experience. As you contribute more and become a prolific member of the open source community, you will start to meet new people online!

Now when you meet potential connections at a meetup/conference/company, you can anchor your experience to a project that they have used or worked on. Contributing to Open Source can also help you in your job search! If you’ve already contributed to an Open Source project in a certain company, you immediately become a very competitive candidate. (Again, there is now very little separating you from the engineers already working at that company!)

Open Source Can Make Your Job Easier

Lastly, your motivation for contributing to an Open Source project may be because you want to make your job easier. If you are using a certain library or framework and notice a bug or need a new feature, take a little time to file an issue and/or work on it!

If the new feature is implemented or the bug is fixed, congratulations! You’ve just made your job easier. Now the logic for your use case is handled by a library that doesn’t rely completely on your future contributions. (As other contributors can continue your work.) In addition, you may have improved the experience for other users of the library or framework!

How Can I Start Contributing?

Hopefully, I’ve convinced you to look into contributing to an Open Source project. But how do you find something to work on?

Look At Your Own Projects

This is usually how I find projects to contribute to. If you’re using a library or framework in your code and notice something wrong with it or want to build on top of it, check out the Github repo!

Search On Github

Github is not just a place to store your version-controlled code. It is also a powerful search tool to find Open Source projects you’d like to contribute to. I recommend using the first-timers-only and good-first-issue tags! (Assuming that corresponds to your skill level.)

Reflect On What You’re Learning

If you’re learning a new technology, what better way to immerse yourself than by checking out some of the projects using it on Github? I particularly love looking at the tooling surrounding a project, such as create-react-app for React.

Publish Your Own Project

Contributing to Open Source doesn’t always mean working on existing projects. You can also publish your own project on to Github! This can help you understand how Open Source works better than just contributing, even if it’s a small project. I published a very simple GraphQL/Node boilerplate called the Artemis Server and learned a lot in the process, though I’m sure that can be its own blog post.

Further References

Interested in learning more about the Open Source community? Here are some awesome
links:

opensource.guide: Ten free, in-depth guides ranging from “How to Contribute to Open Source”, “Building Welcoming Communities”, to “The Legal Side of Open Source”. All made by Github and friends!
opensourcefriday.com: Take some time away from work and give back to the Open Source Community every Friday!
opensourcesurvey.com/2017: Get a feel for the landscape of Open Source
slides.aaroh.codes: The slides from my talk, if you want to give a similar talk to mine. I’m always happy to help you tweak your talk and tailor it to your audience and your experiences! (Just ping me on Facebook.)

Last but not least, here’s a recording of my talk on Youtube! Yes I know it’s portrait, I wasn’t the one filming…

Data Structures and Algorithms: 0 to 60

Aaroh Mankad — Tue, 16 Jan 2018 22:25:25 +0000

Whether for homework or interviews, Data Structures and Algorithms will be foundational to your early career. This article is to help you go from nothing to practical knowledge in this crucial area of Computer Science.

Linked Lists

A Linked List is, as the name suggests, a list of items. Each item points to the next node in the list. Think of a linked list as a scavenger hunt.

You start with a clue (the head of the list), and each clue leads you to the next clue (the next pointer), until you’re at the end (the tail of the list). Can you think of a list implementation?

Every Node is the start of its own Linked List!

Some common reasons to use Linked Lists include:

Inserting elements in the middle of your data : You can insert anywhere in your list as long as you know the Node before the insertion index. O(n) in a Vector, O(1) in a Linked List.
Quicker at expanding space for your data: Because Linked Lists focus on this idea of using pointers, you don’t have to allocate contiguous blocks of memory for your data. This saves you O(n) time compared to a naive implementation of a Vector.

One major drawback of Linked Lists is that you don’t have random access of an element in the list by its index. For example: If you wanted to retrieve the 5th element in a list, you would have to iterate through the list until you ran into it.

Stacks/Queues

A Stack and a Queue are pretty much the same data structure, the only difference being how they order their information. We can implement both with our Node struct from earlier!

A Stack operates last in, first out (LIFO). Think of a stack of cafeteria trays. The last tray you put on the stack will be the first one you pick up off the stack. A stack exposes three main functions: one to see the top, one to push to the top, and one to pop off the top.

A Queue operates first in, first out. Think of a queue of people waiting in line. If you were first in line, you would be helped first. Similarly, if you’re last in line, you will be helped last. A queue exposes the same functions as a stack, with the implementation of push being slightly different. (We want to push to the end of a queue.)

Basic Stack and Queue implementations based off our Node from earlier

Stacks and Queues are great for maintaining order based on insertion time: Use a Stack if you want to keep track of the most recent item. Use a Queue if you want to keep track of the oldest item.

Don’t use either if you care about anything other than the most recent or oldest items.

Trees

A Tree is a data structure that is very suited to parent-child relationships in data. It can be implemented by a simple Node class as we defined above, with the exception of having multiple children pointers instead of one next pointer.

A simple implementation of a tree. Note how every node is the “start” of it’s own subtree!

Trees require a different type of thinking than Vectors, Linked Lists, or even Stacks/Queues. They introduce a concept of traversing a tree. Because there is no set way to go from a parent to a child, you can choose between three main traversal methods:

Pre-Order Traversal

Use a Pre-Order Traversal if you want to calculate something on the parent before doing the same on the children.

Given our tree representation from above:

In-Order Traversal

Use an In-Order Traversal if you want to calculate something on the left child, then the parent, and finally the right child. This is typically only used for binary trees, trees with only a max of two children per Node.

Given our tree representation from above:

Post-Order Traversal

Use a Post-Order Traversal if you want to calculate something on the children before doing the same on the parent.

Given our tree representation from above:

Maps

A Map is a way to represent data in terms of a key and a value. A proper implementation offers very quick insertion, lookup, and removal times.

The base of a good map implementation is it’s hash function. The purpose of this hash is to:

Provide a hashed, or encoded, output given any valid input
Always return the same output given the same input
Minimize collisions, when two inputs returns the same output

Maps are incredibly powerful because of how quickly you can manipulate them. (O(1) for insertion, deletion, and lookup!) This speed lends itself very well for most interview questions, to the point of making them trivial.

Get to know Maps very well.

Graphs

A Graph is a flexible data structure that can be used to represent data with complex relationships between Nodes. It is most similar to a Linked List, but every Node can have n number of pointers to other Nodes. A Graph is also not guaranteed to be free of cycles. (A cycle is when you can start and end at the same Node while traversing the graph.)

A Graph implementation is actually quite simple:

Notice how you can get to a OR c from b, but not necessarily the other way around!

We can model a lot of situations using graphs, such as: friendships between users, airplane routes, etc. Graphs can make any problem with complex relationships quite simple, and going from one Node to another is as simple as traversing through its neighbors. (Examples are mentioned in the Appendix: Path-finding and Dijkstra’s.)

Appendix

These were some of the basic data structures that can be found in course curricula and interview questions. If you want to expand your knowledge further (and go from 60 to 120!), here are some advanced Data Structures and Algorithms:

Cycles in Linked Lists
Using a Stack to evaluate mathematical expressions
Tries: a fancy tree that allows efficient path lookup
Sets: when you only want to remember if you’ve seen an element before(great replacement for map<[anything], bool>)
Path-finding algorithms (Kruskal’s and Prim’s), for when you want to find a path between two nodes in a graph
Dijkstra’s Algorithm: find the path of least resistance between two nodes

Further Resources

If you prefer books over blog posts, I highly recommend (in order of readability):

Algorithms to Live By: The Computer Science of Human Decisions: A great read on how you can apply algorithms in your daily life. Not a very academic read.
Grokking Algorithms: An incredible book for not only its simple explanations and relation to real world examples, but also PICTURES!
Introduction to Algorithms, 3rd Edition: A great reference book, used for Intermediate Data Structures and Algorithms at UCR.
Algorithms, 4th Edition: Written by the legendary Robert Sedgewick, super informative. (Sedgewick has been teaching algorithms since the peak of Fortran!)

Cleaning Up Your Code: Testing

Aaroh Mankad — Wed, 03 Jan 2018 03:47:26 +0000

This is an excerpt from my article "Cleaning Up Your Code" on Medium. I'll be publishing each section daily, read ahead on Medium!

Before I start explaining the specifics of testing in certain languages, I want to start by explaining the concept of Test Driven Development. You may have heard the term before but thought that your project wasn’t big enough to adopt this method of developing.

Test Driven Development (TDD) is a method of developing in which you write tests before you write any code. Why would you want to do this?

TDD actually enforces writing tests for your code! Many times you’ll write a program, run some examples and call it done. However, you’ve likely missed several bugs in your code by testing only the optimal cases. If you did manage to find some bugs and fix them, it is more work to make sure your fix did not break any previous cases. For this reason, tests serve as a method of documentation for all the cases you’ve checked so far and as a way to force you to think of ways to break your code.

So what makes a good test? Follow the F.I.R.S.T method!

Fast: If a test is slow, your approach to the task is probably not optimal. If the test is slow for a sample size of one, imagine how that would scale to a system of a million users!
Independent: A test should not depend on the outcome of another test. In the case that tests were dependent, then your tests would fall in a domino effect, hiding bugs in a different test until you fix the first bug. (Not ideal for when you’re working in teams asynchronously.)
Repeatable: A test should not leave anything to chance. Every time you run a test, assuming no changes to the code have been made, you should expect an identical outcome. If the test cannot be repeated, you will eventually fall into a “It works on my machine!” attitude which is not beneficial to your team or your users.
Self-Validating: A test should return a boolean, true or false. This allows us to automate the job of testing our code, checking if all the tests return true or not. If you have to check some printed output to see if it matches the expected output, you could instead do a diff on the expected string and the returned string. (This changes our test from a string return type to a bool return type!)
Timely : This is the self-fulfilling prophecy in F.I.R.S.T. If you write your tests in a timely manner, your testing will go smoothly. Do not put off writing tests in favor of extending the functionality of your program.

Some housekeeping notes, but keep your tests separate from your actual program logic, ideally in a /tests directory.

Testing can be very domain-specific in its scope. My experience is primarily in Javascript and C++, which I feel represent two very different sides of programming. (Hopefully your language of choice falls somewhere on that spectrum!)

Javascript

Before you start thinking that tests have to be this fancy concept of your code that can only take a significant portion of your development time, remember that a test can be as simple as checking the output of a function to the expected output!

There are more robust ways to write tests in Javascript, mostly due to the vibrant developer community. Most commonly used is the test runner. A test runner will automatically run all your tests and present them in a very clean format. It is also much more extensible in the use case that you have databases of objects and want to mock some test data for your tests.

The test runner that I’m going to recommend is Jest. Jest is used by Facebook to test all their JavaScript code including their React applications. To me, Jest has a lot of reputation from being backed by Facebook and having a team dedicated to its active development.

To learn how to start using Jest, I highly recommend Fun Fun Function:

C++

As in Javascript, sometimes the easiest way to test your code in C++ is with some assert statements.

When you want to get into some more complex testing, such as checking for memory leaks, you may want to start using static analyzers. First, use cppcheck to see if you even have a memory leak in the first place. cppcheck can also offer advice for better performance or cleaner code style.

If you do end up having a memory leak or segmentation fault, one option is to compile your program with the -g flag for debugging support. Then you can run your program with GDB (GNU DeBugger). GDB allows you to set breakpoints in your code, step through functions, inspect values at each step, and locate segmentation faults.

Fun fact: You can also use GDB as a disassembler for executables!

Thanks for reading! How do you test your code?

Cleaning Up Your Code: Consistent Formatting

Aaroh Mankad — Sat, 30 Dec 2017 01:25:58 +0000

This is an excerpt from my article "Cleaning Up Your Code" on Medium. I'll be publishing each section daily, read ahead on Medium!

An age-old debate: tabs or spaces? Braces on the same line or new line?

I’m not going to suggest any specific formatting, but I do want to expose you to some guidelines on deciding formatting for your project. First and foremost, once you’ve found a method of formatting to use, stick to it.

There’s two steps to getting most of the way to a perfect style guide for your project.

Pick a popular style guide for your language. Picking a style guide that more people have been exposed to will reduce the time a new contributor focuses on syntax and more time on making meaningful contributions to your code. Examples are included below.
Make slight variations to it for your specific use cases. If a certain point in your chosen style guide doesn’t make sense for your use case, document it. (Ideally in a CONTRIBUTING.md file!)

Airbnb Style Guide for Javascript
Google Style Guide for C++
PEP8 Style Guide for Python

If you're working in Javascript, I highly recommend using Prettier to automatically handle the formatting for you! I use the JsPrettier Package for Sublime Text.

Thanks for reading! How do you enforce consistent code-style in your projects?

Cleaning Up Your Code: Abstracting Reused Code

Aaroh Mankad — Thu, 28 Dec 2017 19:39:55 +0000

This is an excerpt from my article "Cleaning Up Your Code" on Medium. I'll be publishing each section daily, read ahead on Medium!

If you’ve found pieces of code in your codebase that are heavily duplicated or rely on the same logic, they are probably great contenders for abstraction.

Abstracting code into a separate function or class can help reduce code complexity. If your algorithm related to that block of code changes, you only have to change it in one place versus changing it in multiple places across your codebase.

What does a good abstraction look like? Well let’s take our example from earlier. The great_names.cpp file is really easy to read! However, we would have to rewrite that code block if we ever wanted to find a cell based on a different FLAG_CODE or in a different gameBoard. So let’s move that code into an isolated function.

Before you decide to start splitting your code apart, here are some things to keep in mind:

Keep your functions small: A small function is easy to read, but also very easily reused. Your function should be able to be used for a wide variety of use cases, not just the one case it used to be in.
Limit the functionality: If your code does more than one exact thing, it will be difficult to use it across your codebase. Continue splitting your code until your functions have only one purpose each.Then you can implement a function to call these smaller functions in any way you wish!
Ensure no side effects: A function should be thought of as a walled off piece of code that you control. It should purely accept input and return output. A pure function is a function that does not affect any code it does not have direct access to. A simple example would be an impure add function that adds two variables outside of its scope. This is very hard to keep track of and should be avoided in most situations.

Thanks for reading! What are your approaches to breaking up reusable blocks of code?

Cleaning Up Your Code: Good Names

Aaroh Mankad — Thu, 28 Dec 2017 03:13:42 +0000

This is an excerpt from my article "Cleaning Up Your Code" on Medium. I'll be publishing each section daily, read ahead on Medium!

Programming is not a math equation. The vast majority of the programs you write will not be simple. They will have to interact with the rest of the program, forming complex relationships along the way, and therefore have to be read by other programmers. Someone with no idea of your contribution should be able to quickly understand what your code does.

Let’s look at an example, which code snippet is easier to grasp?

If you’d like to start using good names throughout your codebase, here are some general rules to follow:

Expose meaning through names: Similar to the above example, the name of a variable should provide some meaning towards code functionality.
Use pronounceable names: Software Development involves talking through your code with other developers. It will help a lot if you can actually talk through your code.
Use searchable names: There will be many times you want to track a variable or function through your codebase. In this case, the variable should be unique enough that it can be searched for with few duplicates.

Thanks for reading! How do you make sure your code is understandable to yourself and colleagues?

Bash Functions: A more powerful Alias

Aaroh Mankad — Sun, 24 Dec 2017 18:59:24 +0000

If you use bash a fair amount, you probably have some aliases set up. However, have there been times you wish you had some more control over the functionality of your alias?

Let’s examine one example: a bash alias and a bash function for extracting a file.

With an alias, we can easily abstract out the complicated tar command to simply extract.

Now we can type extract file.tar.gz or extract file.tgz and the command will extract the file. We can even specify output directories!

But what if we can’t rely on our downloaded file to have .tar.gz / .tgz extensions? Well in that case, a function for extract makes more sense!

Now we can call extract without worrying about our file extension! We can just trust that the function will do exactly what it’s meant to.

So how can I start using bash functions?

First, import a file called .bash_functions in your .bashrc.

Now you can either download my .zsh_fns file (bash functions for zsh) as a starting point, or create your own at ~/.bash_functions!

Note: You must restart terminal or type source .bashrc in your terminal to start using the new bash functions