|
8 жил өмнө | |
---|---|---|
extras | 8 жил өмнө | |
.gitignore | 8 жил өмнө | |
README.md | 8 жил өмнө |
If you like this project, please give me a star. ★
This is my multi-month study plan for going from web developer (self-taught, no CS degree) to Google software engineer.
This long list has been extracted and expanded from Google's coaching notes, so these are the things you need to know. There are extra items I added at the bottom that may come up in the interview or be helpful in solving a problem.
Many items are from Steve Yegge's "Get that job at Google" and are reflected sometimes word-for-word in Google's coaching notes.
I'm following this plan to prepare for my Google interview. I've been building the web, building services, and launching startups since 1997. I have an economics degree, not a CS degree. I've been very successful in my career, but I want to work at Google. I want to progress into larger systems and get a real understanding of computer systems, algorithmic efficiency, data structure performance, low-level languages, and how it all works. And if you don't know any of it, Google won't hire you.
When I started this project, I didn't know a stack from a heap, didn't know Big-O anything, anything about trees, or how to traverse a graph. If I had to code a sorting algorithm, I can tell ya it wouldn't have been very good. Every data structure I've ever used was built into the language, and I didn't know how they worked under the hood at all. I've never had to manage memory, unless a process I was running would give an "out of memory" error, and then I'd have to find a workaround. I've used a few multi-dimensional arrays in my life and thousands of associative arrays, but I've never created data structures from scratch.
But after going through this study plan I have high confidence I'll be hired. It's a long plan. It's going to take me months. If you are familiar with a lot of this already it will take you a lot less time.
Everything below is an outline, and you should tackle the items in order from top to bottom.
I'm using Github's special markdown flavor, including tasks lists to check my progress.
I check each task box at the beginning of a line when I'm done with it. When all sub-items in a block are done, I put [x] at the top level, meaning the entire block is done. Sorry you have to remove all my [x] markings to use this the same way. If you search/replace, just replace [x] with [ ]. Sometimes I just put a [x] at top level if I know I've done all the subtasks, to cut down on clutter.
More about Github flavored markdown: https://guides.github.com/features/mastering-markdown/#GitHub-flavored-markdown
I have a friendly referral already to get my resume in at Google. Thanks JP.
Print out a "future Googler" sign (or two) and keep your eyes on the prize.
I'm on the journey. Follow along at GoogleyAsHeck.com
Some videos are available only by enrolling in a Coursera or EdX class. It is free to do so, but sometimes the classes are no longer in session so you have to wait a couple of months, so you have no access. I'm going to be adding more videos from public sources and replacing the online course videos over time. I like using university lectures.
[x] Videos:
[x] Articles:
[x] Additional (not suggested by Google but I added):
This short section were prerequisites/interesting info I wanted to learn before getting started on the daily plan.
You can use a language you are comfortable in to do the coding part of the interview, but for Google, these are solid choices:
You need to be very comfortable in the language, and be knowledgeable. Read more (rescued from the lost web):
- https://web.archive.org/web/20160204193730/http://blog.codingforinterviews.com/best-programming-language-jobs/
You'll see some C, C++, and Python learning included below, because I'm learning. There are a few books involved, see the bottom.
[x] How computers process a program:
[x] How floating point numbers are stored:
[x] Computer Arch Intro: (first video only - interesting but not required) https://www.youtube.com/watch?v=zLP_X4wyHbY&list=PL5PHm2jkkXmi5CxxI7b3JCL1TWybTDtKq&index=1
[x] C
[x] C++
[x] Python
[x] Compilers
Each subject does not require a whole day to be able to understand it fully, and you can do multiple of these in a day.
Each day I take one subject from the list below, watch videos about that subject, and write an implementation in:
C - using structs and functions that take a struct * and something else as args.
C++ - without using built-in types
C++ - using built-in types, like STL's std::list for a linked list
Python - using built-in types (to keep practicing Python)
and write tests to ensure I'm doing it right, sometimes just using simple assert() statements
You may do Java or something else, this is just my thing.
Why code in all of these?
Practice, practice, practice, until I'm sick of it, and can do it with no problem (some have many edge cases and bookkeeping details to remember)
Work within the raw constraints (allocating/freeing memory without help of garbage collection (except Python))
Make use of built-in types so I have experience using the built-in tools for real-world use (not going to write my own linked list implementation in production)
I may not have time to do all of these for every subject, but I'll try.
You can see my code here:
You don't need to memorize the guts of every algorithm.
Write code on a whiteboard, not a computer. Test with some sample inputs. Then test it out on a computer to make sure it's not buggy from syntax.
[x] Before you get started:
[x] Algorithmic complexity / Big O / Asymptotic analysis
If some of the lectures are too mathy, you can jump down to the bottom and watch the discrete mathematics videos to get the background knowledge.
[x] Arrays: (Implement an automatically resizing vector)
[x] Linked Lists
[x] Stack
[x] Queue
[x] Hash table
[x] Videos:
[x] Online Courses:
[x] implement with array using linear probing
[x] Endianness
[x] Binary search:
[x] Bitwise operations
[x] Notes & Background:
[x] Binary search trees: BSTs
[x] Heap / Priority Queue / Binary Heap:
[x] Tries
[x] Balanced search trees
[x] Self-balancing binary search tree: https://en.wikipedia.org/wiki/Self-balancing_binary_search_tree
[x] AVL trees
[x] Splay trees
[x] 2-3 search trees
[x] 2-3-4 Trees (aka 2-4 trees)
[x] B-Trees
[x] Red/black trees
[x] N-ary (K-ary, M-ary) trees
[x] Notes:
For heapsort, see Heap data structure above. Heap sort is great, but not stable.
[x] Bubble Sort: https://www.youtube.com/watch?v=P00xJgWzz2c&index=1&list=PL89B61F78B552C1AB
[x] Analyzing Bubble Sort: https://www.youtube.com/watch?v=ni_zk257Nqo&index=7&list=PL89B61F78B552C1AB
[x] Insertion Sort, Merge Sort: https://www.youtube.com/watch?v=Kg4bqzAqRBM&index=3&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb
[x] Insertion Sort: https://www.youtube.com/watch?v=c4BRHC7kTaQ&index=2&list=PL89B61F78B552C1AB
[x] Merge Sort: https://www.youtube.com/watch?v=GCae1WNvnZM&index=3&list=PL89B61F78B552C1AB
[x] Quicksort: https://www.youtube.com/watch?v=y_G9BkAm6B8&index=4&list=PL89B61F78B552C1AB
[x] Selection Sort: https://www.youtube.com/watch?v=6nDMgr0-Yyo&index=8&list=PL89B61F78B552C1AB
[x] Stanford lectures on sorting:
[x] Shai Simonson, Aduni.org:
[x] Steven Skiena lectures on sorting:
[x] UC Berkeley:
[x] - Merge sort code:
[x] - Quick sort code:
[x] Implement:
[x] For curiosity - not required:
Graphs can be used to represent many problems in computer science, so this section is long, like trees and sorting were.
Notes from Yegge:
[x] Skiena Lectures - great intro:
[x] Graphs (review and more):
Full Coursera Course:
Yegge: If you get a chance, try to study up on fancier algorithms:
I'll implement:
You'll get more graph practice in Skiena's book (see Books section below) and the interview books
[x] Recursion
[x] Dynamic Programming
[x] Combinatorics (n choose k) & Probability
[x] NP, NP-Complete and Approximation Algorithms
[x] Garbage collection
[x] Caches
[x] Processes and Threads:
[x] Scalability & Data Handling:
[ ] About Google:
[ ] Papers:
[ ] Unicode
[ ] System design
[ ] Familiarize yourself with a unix-based code editor: emacs & vi(m)
[ ] Be able to use unix command line tools:
[ ] Testing
[ ] Design patterns
[ ] Scheduling
[ ] Implement system routines
[ ] String searching & manipulations
This section will have shorter videos that can you watch pretty quickly to review most of the important concepts.
It's nice if you want a refresher often.
(More items will be added here)
Read and do exercises:
[ ] The Algorithm Design Manual (Skiena)
Once you've understood everything in the daily plan, and read and done exercises from the the books above, read and do exercises from the books below. Then move to coding challenges (further down below)
Read first:
Read second (recommended by many, but not in Google coaching docs):
[x] C Programming Language, Vol 2
[x] C++ Primer Plus, 6th Edition
[x] The Unix Programming Environment
[ ] Programming Pearls:
[ ] Algorithms and Programming: Problems and Solutions: http://www.amazon.com/Algorithms-Programming-Solutions-Alexander-Shen/dp/0817638474
If you have time:
[ ] Introduction to Algorithms
[ ] Elements of Programming Interviews
Once you've learned your brains out, put those brains to work. Take coding challenges every day, as many as you can.
Dynamic Programming – From Novice to Advanced: https://www.topcoder.com/community/data-science/data-science-tutorials/dynamic-programming-from-novice-to-advanced/
https://courses.csail.mit.edu/iap/interview/materials.php
InterviewBit: https://www.interviewbit.com/invite/icjf
Exercises for getting better at a given language: http://exercism.io/languages
Have a story, not just data, about something you accomplished
Why do you want this job?
What's a tough problem you've solved?
Biggest challenges faced?
Best/worst designs seen?
Ideas for improving an existing Google product.
How do you work best, as an individual and as part of a team?
Which of your skills or experiences would be assets in the role and why?
What did you most enjoy at [job x / project y]?
What was the biggest challenge you faced at [job x / project y]?
What was the hardest bug you faced at [job x / project y]?
What did you learn at [job x / project y]?
What would you have done better at [job x / project y]?
Some of mine (I already may know answer to but want their opinion or team perspective):
Everything below is my recommendation, not Google's, and you may not have enough time to
learn, watch or read them all. That's ok. I may not either.
[x] Information theory
[x] Parity & Hamming Code
[x] Entropy (also see videos below)
[x] Cryptography (also see videos below)
[x] Compression
[x] Networking
[x] Computer Security
[ ] Augmented Data Structures
[ ] Geometry, Convex hull
[ ] Skip lists
[ ] Network Flows
[ ] Linear Programming
[ ] Disjoint Sets & Union Find
[ ] van Emde Boas Trees
[ ] Fast Fourier Transform
[ ] Integer Arithmetic, Karatsuba Multiplication:
[ ] Treap
[ ] Bloom Filter
[ ] Machine Learning
[x] Parallel Programming
[ ] Discrete math (see videos below)
[ ] Go:
--
I added these to reinforce some ideas already presented above, but didn't want to include them
above because it's just too much. It's easy to overdo it on a subject.
You want to get hired in this century, right?
[ ] More Dynamic Programming
[ ] Advanced Graph Processing
MIT Probability (mathy, and go slowly, which is good for mathy things):
[ ] Simonson: Approximation Algorithms: https://www.youtube.com/watch?v=oDniZCmNmNw&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=19
Sit back and enjoy. "netflix and skill" :P
[ ] List of individual Dynamic Programming problems (each is short):
[ ] x86 Architecture, Assembly, Applications (11 videos)
[ ] MIT 18.06 Linear Algebra, Spring 2005 (35 videos):
[ ] Excellent - MIT Calculus Revisited: Single Variable Calculus:
[ ] Computer Science 70, 001 - Spring 2015 - Discrete Mathematics and Probability Theory:
[ ] Discrete Mathematics (19 videos):
[ ] CSE373 - Analysis of Algorithms (25 videos):
[ ] UC Berkeley 61B (Spring 2014): Data Structures (25 videos):
[ ] UC Berkeley 61B (Fall 2006): Data Structures (39 videos):
[ ] UC Berkeley 61C: Machine Structures (26 videos):
[ ] UC Berkeley CS 152: Conputer Architecture and Engineering (20 videos):
[ ] MIT 6.004: Computation Structures (49 videos):
[ ] MIT 6.006: Intro to Algorithms (47 videos):
[ ] MIT 6.033: Computer System Engineering (22 videos):
[ ] MIT 6.034 Artificial Intelligence, Fall 2010 (30 videos):
[ ] MIT 6.042J Mathematics for Computer Science, Fall 2010 (25 videos):
[ ] MIT 6.046: Design and Analysis of Algorithms (34 videos):
[ ] MIT 6.050J Information and Entropy, Spring 2008 (19 videos)
[ ] MIT 6.851: Advanced Data Structures (22 videos):
[ ] MIT 6.854 (Advanced Algorithms), Spring 2016 (24 videos):
[ ] MIT 6.858 Computer Systems Security, Fall 2014 ():
[ ] Stanford: Programming Paradigms (17 videos)
[ ] Introduction to Cryptography:
http://www.gainlo.co/ - Mock interviewers from big companies
Keep learning.
You're never really done.