User:Runner1928

See my Wikipedia user page over at https://en.wikipedia.org/wiki/User:Runner1928

To do
Coding, algorithms, data structure, data design Code on whiteboard, thought process Most questions should be able to be answered in fewer than 30 lines of code Run through the code yourself. Ensure it works. Try to find edge cases. Watch for off-by-one errors! Keep things to simple solutions. With a complex solution, the interviewer has many different ways to poke holes in it. Questions will be progressive. Given your solution A, how will that scale to one billion widgets? Don’t blind-guess the answer. You probably won’t have to prove the order of complexity, but will have to know it. Keep things in linear or log time, avoid exponential for obvious reasons. Many solutions are simple struct classes, sufficient to do the job but not too generic To know: hash tables vectors graphs string parsing combining data structures: e.g., find the median of an array of strings Coding Ability (you will be asked to code on the whiteboard - brush up on syntax and libraries) - Algorithm Design/Analysis - Systems Design - Open-Ended Discussion (remember to think out loud and clarify the problem) Coding - construct / traverse data structures - implement system routines - distill large data sets to single values - transform one data set to another Algorithm Design / Analysis - big-O analysis - sorting and hashing, searching - handling obscenely large amounts of data System Design - feature sets - interfaces - class hierarchies - designing a system under certain constraints - simplicity and robustness - tradeoffs Open-Ended Discussions - biggest challenge faced - best / worst designs seen - performance analysis and optimization - testing - ideas for improving existing products Coding - language familiarity, core libraries, idioms, performance issues Algorithms and data structures Analytical skills System design Communication Use your strongest coding language No pseudocode Seen the question before? Tell your interviewer Explain your thought process If you don't come up with most optimized solution first, present a simple solution then optimize as you go Run through examples to check for correctness Check again for edge cases Use reasonable variable names Clean up code after first pass Concepts students should familiarize themselves with: 1.) Algorithm Complexity: Big-O http://www.topcoder.com/tc?module=Static&d1=tutorials&d2=alg_index
 * Software engineer technical interview preparation: external resources
 * [Book] Programming Interviews Exposed
 * [Book] The Algorithm Design Manual by Steve Skiena
 * [Online Course] The Coursera algorithms courses taught by Tim Roughgarden (Stanford)
 * Structure and Interpretation of Computer Programs,”
 * “The Mythical Man-Month,”
 * “Programming Pearls,”
 * “The Practice of Programming,”
 * “Code Complete,”
 * “The Psychology of Computer Programming.”
 * Knuth’s “The Art of Computer Programming”
 * Hackers Delight, by Warren.
 * Introduction to Algorithms, by Cormen, Leisersen, Rivest (and now) Stein.
 * Programming Pearls, by Jon Bentley (also More Programming Pearls).
 * Computer Architecture: A Quantative Approach, by Hennessy & Patterson.
 * Design Patterns 
 * Refactoring 
 * Code Complete 
 * The Pragmatic Programmer 
 * Secrets to Landing Your Next Job (Programmer to Programmer) by John Mongan, Noah Suojanen, and Eric Giguere
 * Review of Basic Algorithms: Introduction to the Design and Analysis of Algorithms by Anany Levitin
 * https://sites.google.com/site/steveyegge2/five-essential-phone-screen-questions
 * http://steve-yegge.blogspot.com/2008/03/get-that-job-at-google.html
 * http://www.youtube.com/watch?v=w887NIa_V9w
 * http://www.kegel.com/academy/getting-hired.html
 * http://www.topcoder.com/tc?module=Static&d1=tutorials&d2=alg_index
 * http://www.youtube.com/watch?v=oWbUtlUhwa8
 * http://www.youtube.com/watch?v=qc1owf2-220&list=PL5BFE1F0C739D5C24&index=2
 * http://www.youtube.com/watch?v=5wa9J7iXOh0&list=PL5BFE1F0C739D5C24&index=1
 * http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=alg_index
 * http://www.thesimplelogic.com/2012/09/24/you-say-you-want-an-education/
 * https://code.google.com/codejam/
 * https://developers.google.com/open-source/soc/
 * https://developers.google.com/academy/
 * https://developers.google.com/live/
 * http://projecteuler.net/
 * http://www.youtube.com/playlist?list=PL5BFE1F0C739D5C24
 * Next: group by category and give overview of types of questions commonly asked and general necessary areas of knowledge + links to Wikipedia & Wikiversity & other wiki projects

2.) Coding: You should know at least one programming language really well, and it should preferably be C++ or Java. C# is OK too, since it's pretty similar to Java. You will be expected to write some code in at least some of your interviews. You will be expected to know a fair amount of detail about your favorite programming language. Interviews Exposed; Secrets to landing your next job by John Monagan and Noah Suojanen (Wiley Computer Publishing) http://www.wiley.com/WileyCDA/WileyTitle/productCd-047012167X.html
 * Strongly recommended* for information on Coding: Programming

3.) Sorting: Know how to sort. Don't do bubble-sort. You should know the details of at least one n*log(n) sorting algorithm, preferably two (say, quicksort and merge sort). Merge sort can be highly useful in situations where quicksort is impractical, so take a look at it.

4.) Hashtables: Arguably the single most important data structure known to mankind. You absolutely should know how they work. Be able to implement one using only arrays in your favorite language, in about the space of one interview.

5.) Trees: Know about trees; basic tree construction, traversal and manipulation algorithms. Familiarize yourself with binary trees, n-ary trees, and trie-trees. Be familiar with at least one type of balanced binary tree, whether it's a red/black tree, a splay tree or an AVL tree, and know how it's implemented. Understand tree traversal algorithms: BFS and DFS, and know the difference between inorder, postorder and preorder.

6.) Graphs: Graphs are really important. There are 3 basic ways to represent a graph in memory (objects and pointers, matrix, and adjacency list); familiarize yourself with each representation and its pros & cons. You should know the basic graph traversal algorithms: breadth-first search and depth-first search. Know their computational complexity, their tradeoffs, and how to implement them in real code. If you get a chance, try to study up on fancier algorithms, such as Dijkstra and A*.

7.) Other data structures: You should study up on as many other data structures and algorithms as possible. You should especially know about the most famous classes of NP-complete problems, such as traveling salesman and the knapsack problem, and be able to recognize them when an interviewer asks you them in disguise. Find out what NP-complete means.

8.) Mathematics: Some interviewers ask basic discrete math questions. We are surrounded by counting problems, probability problems, and other Discrete Math 101 situations. Spend some time before the interview refreshing your memory on (or teaching yourself) the essentials of combinatorics and probability. You should be familiar with n-choose-k problems and their ilk – the more the better.

We’re interested in how you approach problem-solving. Think out loud. Ask questions. Our questions will be in-depth. We want to see how you think about complicated problems. The right answer would be nice but it is not necessary – your thought process is more important. You will most likely be coding on a white board or a piece of paper. Interview topics may cover anything on your resume (especially if you have stated that you are an expert!), whiteboard coding questions, building and developing complex algorithms and analyzing their performance characteristics, logic problems, systems design and core computer science principles - hash tables, stacks, arrays, etc. Computer Science fundamentals are a prerequisite for all engineering roles, regardless of seniority, due to the complexities and global scale of the projects you would end up participating in. It's OK to question your interviewer. When asked to provide a solution, first define and frame the problem as you see it. If you don't understand - ask for help or clarification. If you need to assume something - verbally check its a correct assumption! Describe how you want to tackle solving each part of the question. Always let your interviewer know what you are thinking as he/she will be as interested in your process of thought as your solution. Also, if you're stuck, they may provide hints if they know what you're doing. Finally, listen - don't miss a hint if your interviewer is trying to assist you! We are not simply looking for engineers to solve the problems they already know the answers to; we are interested in engineers who can work out the answers to questions they had not come across before."

Listening and comprehension Ask the right questions Don't use brute force solutions Don't assume things Find multiple solutions and choose the best Be open to new ideas and ways of solving the problem Ask questions to move to a more complex answer Readable, well-written, and efficient code.


 * Power and Authority of Images
 * Susan Sontag, Regarding the Pain of Others
 * Shusaku Endo, Silence
 * Saint John of Damascus, Three Treatises on the Divine Images
 * Ignatius of Loyola, Spiritual Exercises
 * John Calvin's Institutes of the Christian Religion 1.11-12
 * Mary Shelley's Frankenstein
 * Blade Runner
 * Power rankings