Job Interview Tips

 

Here are some hints and tips to help you prepare for success! Those who study tend to do FAR better on their interviews!

1) Plan ahead:
The Google engineers who will be interviewing you have only limited
time set aside from their projects, so please reserve time in your
schedule, too! This also helps you relax and perform better at
interview. Please have a pen and paper handy in the case that you are
asked to write some things down.

2) What to Expect:
Up to a 45 minute technical interview with a Google software engineer.
The interviewer will be interested in your knowledge of computer
science principles (data structures, algorithms etc.) and how they can
be used in your solutions.

3) Interview Questions:
Interview topics may cover anything on your CV (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 pre-requisite for all engineering roles at
Google, regardless of seniority, due to the complexities and global
scale of the projects you would end up participating in.

4) How to succeed:
At Google, we believe in collaboration and sharing ideas. Most
importantly, you'll need more information from the interviewer to
analyze & answer the question to its full extent.
* Its 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 whether it is 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!

5) What is Google looking for?:
"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."

Interviewers will be looking at the approach to questions as much as
the answer -
* Does the candidate listen carefully and comprehend the question?
* Are the correct questions asked before proceeding? (important!)
* Is brute force used to solve a problem? (not good!)
* Are things assumed without first checking? (not good!)
* Are hints heard and heeded?
* Is the candidate slow to comprehend / solve problems? (not good!)
* Does the candidate enjoy finding multiple solutions before choosing
the best one
?
* Are new ideas and methods of tackling a problem sought?
* Is the candidate inventive and flexible in their solutions and open
to new ideas
?
* Can questioning move up to more complex problem solving?

Google is keen to see really high quality, efficient, clear code
without typing mistakes. Because all engineers (at every level)
collaborate throughout the Google code base, with an efficient code
review process, it's essential that every engineer works at the same
high standard.

7) Ask more questions!:

Make sure you have a decent understanding of Google as a business -
further than Google's main products - find out about what we do here:
http://www.google.com/corporate/ OR:
http://en.wikipedia.org/wiki/Google
At the end of the interview, most interviewers will ask you if you
have any questions about the company, work environment, their
experience, etc. Its clever to have some pre-prepared for each
interview, but don't worry too much if your mind goes blank.

If you have questions about the interview process, remuneration or
your performance, please direct these to your recruiter.


8) Further reading:
*To understand how Google's development teams work -
http://en.wikipedia.org/wiki/Agile_development
*To know more about Google's core projects -
http://labs.google.com/why-google.html
If you have not already read through Steve Yegge's technical prep
tips, please check out his blog -
http://steve-yegge.blogspot.com/2008/03/get-that-job-at-google.html
*Due to the size of the products you'll be building, its imperative
you're comfortable with big O notation, here's where to brush up -
http://en.wikipedia.org/wiki/Big_o_notation


9) Technical Preparation tips!:
The main areas software engineers should prepare to succeed at
interview at Google:

Algorithm Complexity: You need to know Big-O. If you struggle with
basic big-O complexity analysis, then you are almost guaranteed not to
get hired.

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.

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.

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.

Graphs: Graphs are really important at Google. 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*.

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
.

Mathematics: Some interviewers ask basic discrete math questions.
This is more prevalent at Google than at other companies because 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.

Operating Systems: Know about processes, threads and concurrency
issues. Know about locks and mutexes and semaphores and monitors and
how they work. Know about deadlock and livelock and how to avoid them.
Know what resources a processes needs, and a thread needs, and how
context switching works, and how it's initiated by the operating
system and underlying hardware. Know a little about scheduling. The
world is rapidly moving towards multi-core, so know the fundamentals
of "modern" concurrency constructs.

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.

10)Sample Topics:
Coding
Sample topics: construct / traverse data structures, implement system
routines, distill large data sets to single values, transform one data
set to another.

Algorithm Design / Analysis
Sample topics: big-O analysis, sorting and hashing, handling obscenely
large amounts of data. Also see topics listed under 'Coding'.

System Design
Sample topics: features sets, interfaces, class hierarchies, designing
a system under certain constraints, simplicity and robustness,
tradeoffs.

Open-Ended Discussion
Sample topics: biggest challenges faced, best/worst designs seen,
performance analysis and optimization, testing, ideas for improving
existing products.


To practice for your interview you may want to visit the website
www.topcoder.com
If you launch the "Arena" widget and then go to the practice rooms
where you can play with the problems in the first/second division as a
warm up.

I know this was a lot to read, but I wanted you to be prepared.