The Wretched Google Interview Experience

I would like to describe my experience interviewing with Google, and specifically outline why I thought the experience was poor by way of telling my story. As you shall see, this will be especially difficult to convey because you, the reader, will likely be convinced my poor experience is likely only a result of being sour about not being accepted rather than an a posteriori analysis of the events that occurred. There are two conclusions I would like to make: First, Google is extremely bad at communication and human-to-human relationships in general (this is largely known by their customer service, or lack thereof), and second, that Google’s interview process is flawed.

Since I don’t want this to come off as a sob story, I will try to make it somewhat interesting by talking about the questions I got and keeping it in the style of a story rather than a complaint.

Initial Contact

A Google recruiter contacted me almost a year ago. I was working for a company in Colorado at this point, but I was in a bit of dismay concerning some financial mishaps that occurred, and I was interested in seeing what other opportunities there were. So I responded to the recruiter saying that I was interested. At this point, Facebook had also coincidentally contacted me and were interested as well. Both Facebook and Google promptly set up an interview, and I was sure to—at their request—let both of them know that I was interviewing for one another.

A week goes by, Facebook had already set up a phone interview, but Google was sort of tripping over itself. They said they would set up an interview within a couple of weeks, but nothing happened. I email them a few times, and I get no response.

A few weeks more go by, I’ve done phone interviews with Facebook and flown out to their offices to interview, and I’m extended an offer. Now I’m in a dilemma. Google says they are interested, but Facebook has given me an offer. I email Google one last time, and they never respond.

I accepted the Facebook offer, though somewhat reluctantly, because I felt I was closing out on another opportunity.

The Move

I decided to drive from Minnesota to California—a few days’ trek—after about a month since I accepted. (I wanted some time to pack things, get everything situated, change banks, find a place to live, etc.) After the month passes by, and I am on the road, driving through the Rocky Mountains, I get a call from a California phone number. I answer it, and it is another Google person. They tell me they are interested in interviewing. I told them that is what they said two months ago, and said that they would set up dates and times, but never did. The guy I was speaking to sounded somewhat sorry, but explained it must have just been an error in the system. I told the person that I was currently driving, and also that I had a new job starting in a couple weeks, but would still be interested in talking with him. He said he would call again later to discuss things.

The person did call again, and now I was in a more comfortable position. In a hotel room in Reno and not at a wheel in the mountains. The person asked what I was interested in, asked me about languages I’ve used, asked me if I’d be willing to work at Google despite having accepted a job, etc. I showed interest, and did want to move forward, which he acknowledged, and he said he’d email me the next steps.

I finally have moved into my apartment in California and started work. Many months go by, and was even interviewed and extended a better offer by another company, and Google never sent me the email.

Google’s Re-ignition

My interactions with Google started in about October of 2012, and Google called me in May of 2013, a third recruiter who saw me via LinkedIn, oblivious of my past interactions. Again, I got the “we are interested in interviewing.” This time, the recruiter did follow through and continue communication. However, the communication was not very pleasant. It was very canned and calculated. The recruiter asked me a questions like “Which language are you most comfortable in?” to which I answer that I am comfortable in many languages, and they respond “Well is it Python, C++, or JavaScript?” I tell them I have programmed professionally in all three of them and they just pigeonhole me into the Python category.

At around this time that Google contacted me, I had an offer from another company already. I told Google this, and they said they were happy to expedite things. They asked me if I knew anyone at Google, and in fact, I did. I knew four people. I was told that one of them gave me a shining recommendation, another described our work in the Lisp world and recommended me, another (very senior) who doesn’t know me as well nonetheless recommended me, and lastly someone at the director level did say I should be interviewed and also passed around my resume internally.

Finally, Google set up an on-site interview.

The Google Interview

Despite Google’s terrible track record so far for being organized and getting things done, I was still excited. I was so excited, I unfortunately could not sleep the night prior.

I drive to Google’s campus and wait about 30 minutes. The person I was supposed to meet went on a trip and did not tell me except via an automatic email that I received after emailing him asking “Where are you?” The recruiter comes along as backup and finds me, and takes me to my first interview. She asks me if I am ready, if I have used Google products before, and ensures that I will do just fine on the interviews as long as I am confident.

Interview #1: Maps and Sets

The first interviewer came and was 15 minutes late, but did get started right away. He asked me the following question

Create a data structure that has fast insertion, removal, membership testing, and random selection.

I poke around for a little bit and end up writing a chart of three or four elementary data structures, outlining the time complexities of each operation, but I suspected there was something better, which was confirmed by the interviewer’s push to see if I could develop something better. So next I try to mix the best attributes of one data structure with another. After some thinking, I finally got the details hammered out and mixed a hash table and a vector to produce something that has amortized constant everything. I felt victorious, especially since it is something I had to discover on the fly. For those interested, the code is here.

Interview #2: Servers and Data

The next interviewer came in, and he totally crushed me. I’m not even sure if I remember the question correctly.

If you have $n$ servers that take requests, and server $S_i$ can take a request every $t_i$ seconds, and you need to distribute requests to them as efficiently as possible, how do you do it?

I fumbled around a lot, trying to create an efficient loop, modding a timer and switching to the machine that needed the request. Then he asked how I’d add more machines at runtime, and I turned this loop with fixed time points into a data structure that associated $t_i$ to $S_i$. The interviewer thought this was completely unsatisfactory, and said “I wanted you to use a priority queue. We will just move to another question.” I felt pretty bad about this, but he asked another question.

If you have $n$ machines with a 10 GB string of characters on each, how do you find the most common character?

I got this one I thought. Just ask for a distribution of each character from each machine, send the tables to a master machine which added them up and found the character with the highest frequency. Then he asked questions like “If we make the network faster, does it make sense to send over all the data to one machine?” I respond “no”, and explain that it would actually degrade performance. Finally, toward the end, he asked

Now suppose you are in the middle of Africa, each machine is on an Edge network, and each packet between the machines costs $1.00. Write a solution that minimizes the cost.

There was only 5 or 10 so minutes left, but I thought that maybe I could incrementally determine the maximum. I started off by saying that each machine calculates a frequency table, but instead of sending the whole table, the master machine asks for the most common. I start describing very roughly the algorithm for doing this, but I don’t think I was getting the details and corner cases right. Time was very pressured, and the interviewer expressed dissatisfaction with what I’ve done. “Time’s up. Maybe you can ask your friend there what the answer is.” My friend was one of the people who recommended me and took me to lunch. He didn’t know the answer off the top of his head either.

I felt a bit unhappy with my performance, but thought that I got far enough that I must have did at least okay. I ate lunch with two of the people I know at Google, and one of them looked at my “docket” and exclaimed “this question is illegal.” He didn’t tell me which one but he wrote something down and gave it back to me. We finished lunch talking about language runtimes, Lisp, and Go.

Interview #3: Trees

This was probably the most straightforward interview. It started off with a discussion about languages. What’s good about C? What’s bad about it? What languages solve those problems? What languages introduce new ones? I mostly discussed type safety and memory safety, two things that I deal with most often in industrial code.

Then he moved for a technical question. I’m not sure if I remember the question accurately, though.

Given a list of pairs $(a,b)$ where $a$ is the number of a node and $b$ is its parent, construct a tree and return the root.

There may have been a third value $c$, but I fail to remember what it was if it even was.

I blazed through this. I wrote the code down to do so correctly and quickly the first time, and the interviewer actually said “I probably should not have asked a Lisp programmer about trees.” We spent the rest of the time (there was a lot of it) talking about Google and his position. I was particularly keen to figure out if he and his peers were solving tough problems or if most of the work was just tedium. I at least got an indication that he enjoyed what he did, but my question wasn’t really answered. Interview ended, and I felt good again.

Interview #4: Intervals and Regexen

I get to my next interview, performed by a very nice man with a quiet, Russian accent. He asked me the following question, though he asked it more cryptically than I write:

If you have a set of $n$ disjoint, sorted intervals $I = \bigcup_{k=1}^n [a_k, b_k]$, and you have an interval $I’ = [x,y]$, compute $I\cup I’$.

I’d worked with interval arithmetic before, and so I was in somewhat familiar territory. I quickly noted all of the possible cases, and proceeded to implement a solution that was actually more general than what the interviewer asked. I instead wrote a solution for the problem of computing $I$ efficiently given $I_1,\ldots,I_{n+1}$. It is a very easy generalization, and the interviewer saw that I think. Simplifying the union took no extra space and only took linear time, which was a sharp lower bound because we have to examine each possibly-overlapping interval at least once. The code for this is here.

He then proceeded to ask me questions about regular expressions, then asked me to write the regular expression for a variety of things.

Write a regular expression for floating point numbers.

I went through it, and even talked about what the DFA would look like, and describe why it would be very efficient to match.

I was even happier. Maybe lunch had helped! I thought this interview was a roaring success. We even had plenty of time to talk about Google and other things.

Interview #5: Dynamic Programming

The last interview was mostly okay.

Given a set of Lego bricks of height 1, 2, 3, and 4, each colored differently, write a program to compute the number of ways of constructing a tower of height $n\ge 1$.

This wasn’t a foreign question. Very quickly, I wrote down the typical exponential solution; just recursively count. It looks almost exactly like Fibonacci, but with four branches instead of two. I said it could be made a lot better, and computed in linear time. Here, I choked up a bit. I’ve done this a million times before. I started writing the iterative solution in Scheme, but I wasn’t getting the base cases quite right. I had to write out a few of the iterations, and after all that, I finally wrote it down, relieved. It felt almost scary, to forget something so trivial. The interviewer asked me if I could think of another way, and I couldn’t. Then he wrote down a 4-by-4 square matrix, and I basically completed his sentence: “Oh yes, of course, a nearly right triangular matrix that you project onto the first dimension by right-multiplying by a unit vector after doing binary exponentiation to $n$, just like Fibonacci.” I wrote down quickly using mathematical notation what the binary exponentiation looks like and what the projection looks like. He agreed, and we sat down and chatted some.

[Edit 1/10/2014] Many have asked how this works. Recall that the difference equation for Fibonacci numbers $F_k$ is \[F_{k+2} = F_{k+1} + F_k,\] along with the typical initial conditions $F_0 = 0$ and $F_1 = 1$.

This can be succinctly written as a matrix equation \[
\left(\begin{array}{c}
F_{k+2}\\
F_{k+1}
\end{array}\right)
=
\left(\begin{array}{cc}
1 & 1\\
1 & 0
\end{array}\right)
\left(\begin{array}{c}
F_{k+1}\\
F_{k}
\end{array}\right).
\] You can verify this by manually multiplying it out. By induction, this equation is \[
\left(\begin{array}{c}
F_{n+1}\\
F_{n}
\end{array}\right)
=
\left(\begin{array}{cc}
1 & 1\\
1 & 0
\end{array}\right)^n
\left(\begin{array}{c}
F_{1}\\
F_{0}
\end{array}\right).
\] The key here is that matrix exponentiation can be computed in $O(\log n)$ time by way of binary exponentiation. That is, to compute $M^n$ if $n$ is even, simply compute $M^{n/2}$ and square that result. If $n$ is odd, then compute $MM^{n-1}$.

Now we can generalize this to the Lego brick problem. Let the number of ways to arrange a tower of $n$ bricks be $L_n$. Then we have the difference equation \[L_{k+4} = L_{k+3} + L_{k+2} + L_{k+1} + L_{k},\] along with the initial conditions $L_0=1$, $L_1=2$, $L_2=4$, and $L_3=8$. (We will soon see that we can “simplify” the initial conditions, so as to remove the need to actually manually count them.) Similarly, it has the matrix relation \[\left(\begin{array}{c}
L_{k+4}\\
L_{k+3}\\
L_{k+2}\\
L_{k+1}
\end{array}\right)
=
\left(\begin{array}{cccc}
1 & 1 & 1 & 1\\
1 & 0 & 0 & 0\\
0 & 1 & 0 & 0\\
0 & 0 & 1 & 0
\end{array}\right)
\left(\begin{array}{c}
L_{k+3}\\
L_{k+2}\\
L_{k+1}\\
L_{k}
\end{array}\right).\] This can also be verified by expanding out. The intuition behind getting such a matrix is that column $c$ corresponds to $L_c$ in the input, and each value in the row is added up. So for a Fibonacci-like problem of size $N$, the first row—a row of $N$ 1′s—represents the sum of the last $N$ function values or “states” of the solution of the difference equation. And then each row indexed $m$ after the first must simply refer to the $(N-m)$th state, which that leads to an $(N-1)\times(N-1)$ identity matrix, padded with a column of 0′s on the right. So this technique lets us solve the difference equation \[ Q_{k+N} = \sum_{i=0}^{N-1} Q_{k+i} \] efficiently. (Exercise to the reader: This technique actually will let us solve a slightly more general difference equation of this form. What difference equation does it solve and what is the technique?)

Getting back on track to the Lego problem, the recursive matrix equation leads to the closed form matrix equation \[\left(\begin{array}{c}
L_{n+4}\\
L_{n+3}\\
L_{n+2}\\
L_{n+1}
\end{array}\right)
=
\left(\begin{array}{cccc}
1 & 1 & 1 & 1\\
1 & 0 & 0 & 0\\
0 & 1 & 0 & 0\\
0 & 0 & 1 & 0
\end{array}\right)^n
\left(\begin{array}{c}
L_{3}\\
L_{2}\\
L_{1}\\
L_{0}
\end{array}\right).\] If we adjust the indexes, and allow $L_{k<0} = 0$ (which is intuitively correct, we can make 0 towers with fewer than 1 block), then we can write a bit more elegantly \[\left(\begin{array}{c}
L_{n}\\
L_{n-1}\\
L_{n-2}\\
L_{n-3}
\end{array}\right)
=
\left(\begin{array}{cccc}
1 & 1 & 1 & 1\\
1 & 0 & 0 & 0\\
0 & 1 & 0 & 0\\
0 & 0 & 1 & 0
\end{array}\right)^n
\left(\begin{array}{c}
1\\
0\\
0\\
0
\end{array}\right).\] And indeed, this column vector multiplication is a projection of the matrix exponentiation (computed by way of binary exponentiation) onto the first dimension, which reduces the problem to $O(\log n)$ memory (stack space) and $O(\log n)$ time. We can do $O(1)$ space—equivalent to the dynamic programming approach—by doing the binary exponentiation bottom-up. (We can do this by looking at the binary representation of $n$.)

The Aftermath

I actually felt pretty good about my performance. I heard rumors that it’s okay to have a dud, and I thought I was in an especially favorable position since I had four people recommending me at various degrees, and since I nailed most of it.

I was called the next day by one of the recruiter managers, who was aware that I had a job offer elsewhere at this time, and left a message. “4 of the 5 interviewers have given me feedback, and it’s looking really good. I’ll let you know next week on Tuesday.” Monday was Memorial Day. I felt like I had it in the basket. A definite 4/5 and four employees on my side.

Tuesday rolls around, I eagerly await the phone call, and no one calls. Nor Wednesday or Thursday. It’s Friday again. Nothing. I shoot off an email:

It’s been a week since I heard anything from your end and was wondering if there’s any update before the weekend. (The last update I got was a voicemail message from you last Friday.)

About two weeks roll by, and I had no choice but to accept the job offer I was given weeks prior. A few days after I accept the other offer, Google does call me and said something along the following:

We decided we do not want to continue. You were a strong candidate but we felt you could use more experience. You can try again in 18 months. Sorry, I can’t give you any feedback otherwise.

This left me baffled. More experience in what? My resume needed more years, or I needed more algorithmic chops? I didn’t pressure him nor did I argue with him, but it suffices to say I was extremely surprised.

Google Rings Again and Again

A month or so later, a Google recruiter contacts me, and says “we are interested in interviewing.” What? Okay. I tell them, in full disclosure, that I just interviewed with them. They quickly get back to me and say

Oops! Sorry I didn’t see you in our database already. If you have any friends that want to interview, please let me know.

They also invited me to be a connection on LinkedIn, which I did not accept.

A few months go by, and I am on vacation in Boston, just hanging out with friends. I get a call. It’s Google. “We are interested in having you interview.”

I thought it was another mistake, but they acknowledge that I interviewed before, and they said that the 18-month rule is still in effect, but they were considering me for a Software Engineer in Test (SET) position instead.

There were two scheduled phone calls with the recruiter, and we discussed the position and how to move forward, and he sets up a phone call with an SET. The phone call with the SET was phenomenal I thought. An extremely nice guy, explained what he did very well. We chatted about my position, and he said I would probably be way more fit for a Software Engineer (SWE) position instead. I told him my past interview experience and he said something like

If I were Google, I’d cut the crap and just hire you.

That was very encouraging and somewhat flattering. Our phone call ended and he gave me his contact details and all.

I talked to the recruiter again who said that he would pass around my resume and see if any managers were interested, and I would do a half-day interview again. After he said that, a few hours pass and he emails me back saying “the managers would like to do a phone screen.”

What?

They have tons of data about me already, and they want to screen me? I can’t say no, so I say okay, and they set up a phone screen for the week after.

The Phone Screen

I get a call for the phone screen, and was asked to direct my browser to a Google Docs document. The interviewer dove right in.

Given a timer time() with nanosecond accuracy and given the interface

interface RealTimeCounter:
    void increment()
    int getCountInLastSecond()
    int getCountInLastMinute()
    int getCountInLastHour()
    int getCountInLastDay()

implement the interface. The getCountInLastX functions should return the number of times increment was called in the last X.

To be clear, “in last $\Delta t$” means “the number of times increment was called between the current time $t_{\mathrm{cur}}$ and the time $t_{\mathrm{cur}} – \Delta t$, where $t_{\mathrm{cur}}$ is monotonically increasing. This was determined by the interviewer implicitly agreeing with my initial solution. [Edit 8/20/2013]

I froze up. How do I implement this? I just started coding.

I whip something up along the following lines: keep a history of timestamps and bisect it to find the least time greater than or equal to current_time - X. I knew there were issues with this. Theoretically, memory grows linearly with increment and is practically unbounded. (Theoretically, it is bounded because the timer is quantized, but practically, you can construct a case where memory fills up.)

I also discussed a way to prune the timestamps quickly, and it can be done on every query or every increment.

I spent the rest of the time trying to think of a way to bound the memory. The interviewer did not provide any hints or help, nor did he give any indication about what the actual issue with the code was. (In other words, I identified the issue with unbounded memory.) They simply said “would you like to spend the last 15 minutes cleaning this solution up or figuring out a better one?” I said I’d spend 5 more minutes thinking, and I’d make my decision then.

I couldn’t think of a better way, but did discuss some rough ideas. Could we bucket the times somehow? How do we deal with the edges of the buckets? I talked about a way to map time intervals to buckets, but failed to incorporate it into my solution. After 5 minutes was up, I stayed with my word and just cleaned up what I had.

The interview ended and I was mortified, I felt like I failed. Although I did write a full, working solution that had efficient time complexity, and theoretically efficient memory complexity, I knew it wasn’t practically sufficient. But something is better than nothing, yes?

I was told that I would be contacted within a day or two.

Post-Screen

I went online and asked two Google employees this question, two Amazon employees, an ARM employee, a CS PhD student, and a few other very smart people, but none of them came back to me with a solution that bounds the memory. One of the Google employees talked with one of their Google friends about it, and the friend said something like “It’s the interview question that people know because they look up the answer. And everyone always looks up the answer.” He proceeded to give me a hint over email about modding the timestamps, but I still fail to understand how it helps with edge cases (where the bucket size is greater than the resolution of the timer).

I hadn’t thought about it much, and a few of the people I talked to said they thought about it and still couldn’t figure it out.

A few days pass, and Google hadn’t contacted me. A week passes, and I email. No response. I call. No response. It has been a month minus two days, and Google still has not reached out to me.

My Google friend emails me telling me that he just gave me a recommendation to a Computer Science PhD position and said that it went well. He also added to the email that he checked my file at Google and saw that I was not accepted. But to this day, that has never been officially said.

Afterthoughts

Google has simply shown, in my opinion, an extreme lack of respect for the interviewee. Massively delayed or non-existent communications, sloppy bookkeeping, canned responses, pandering for applicants, etc. My interviews only consisted of a barrage of highly technical questions. Not once was my resume brought up. Not once was I asked about me in an interview.

Aside from being terrible at communication, Google implicitly rejected, without appeal, someone with offers for a PhD and someone who owns two checks from Knuth. But of course, credentials are not sufficient. My repositories, that contain code ranging from complicated group theoretic computations to implementations of set covering algorithms, meant nothing to them, even though I believe they subsume all of the gymnastics they put their interviewees through. It is a shame to see that current Google employees may also not have a job there, were they given the same set of interviewers as I had under the same circumstances. (And don’t get me wrong, they are extremely bright people and should be working at a top-tier company.)

Overall, I am quite appalled with Google’s interactions with me over the past year, and if there is this much contempt for interviewees like me, I wonder if they should be held in the same position.

More on interviewing in Silicon Valley can be found in this post.

93 comments to The Wretched Google Interview Experience

  • Chris

    That’s a better experience than I have had. :-)

  • Ilikechallenges

    Google is just a big marketing corporation. They might have been cool to work for 5 years ago but not now.

  • Derrick D

    Dude, have some dignity. Why are you so hard up to work for Google?

    • I wouldn’t say I am “hard up” to work for them just because I have accepted to interview with them. I have continually worked elsewhere during the time.

      I think it would be a different story if I rejected opportunities and just set my sights on Google, which is not the case.

  • Me2

    My questions were different, but the rest of the interview could have been my own story. I was initially excited at the idea of working for Google but the process ground that out of me. By the time they gave me your exact same response (“get some experience and come back”, really?), I was so disgusted with their disregard that I no longer cared.

    I didn’t end up at Facebook, but their process was the exact opposite of Google’s. I went from initial contact to on-site in a couple of weeks.

    My most recent interview was with a SF startup. A couple of coworkers spent a few minutes grilling me, decided (partially thanks to my Stack Overflow and Github profiles) that I knew my stuff, then spent a couple of hours having a friendly conversation. I’d talked about my work projects and what I liked and disliked about them. They talked about their architecture, problems they’d solved and were still working on, and what life at their company was like. It was the most mutually useful interview I’ve ever had as they treated me like an experienced peer. They offered and I accepted. That’s how things should always work.

  • Lucas

    Dude. Just consider yourself lucky. You dodged a bullet. Did you really want to work for a company that treats people that way?

  • Google, like many organizations who seek the best people, finds hiring and interviewing very difficult. Google also experiences particular problems since there are scaling issues when you seek to keep hiring great people at increasing scale. Google is good at improving technical processes and making them scale… worse so for things related to humans.

    Your experience is unfortunate; I can’t speak to how typical it is with any real authority. But it is interesting to see what the drivers are. Here’s some background, based on my knowledge from having been an intern 3x, friends who work there, and general curiosity about Google / etc.

    On the recruiters
    You had so many contacts (before and after) since there are people whose job it is to find talent; they are judged based on how many people they find… so you can see why so many kept contacting you. If they didn’t look you up internally, it sounds more like poor execution since there should be reasonably good systems to avoid that duplication!

    On the interviewing
    Sounds like you experienced some decidedly un-Googley behavior, which is disappointing. People cling to the idea that ‘more data’ will make interviews better… and thus more interviews. Google used to have 10+ commonly, until it instituted various iterations of rules to cap that (5, circa 2011) [http://www.businessinsider.com/the-google-investor-feb-8-2011-2]. People thought that more interviews were more predictive until it was determined, they were not! I see this same problem at other companies with smart people who haven’t done the HR analytics.

    On the outcome:
    (1) Remember, Google hires by committee. [https://www.quora.com/Google/What-happens-during-a-Google-hiring-committee-meeting] Therefore, whatever happened in the interviews, other people reviewed that information and made a decision. So… anything could be parsed differently from how you expect. (2) There is a good reason for no appeal – both practical, legal, otherwise. If Google (or any company) commonly gave out feedback about why someone wasn’t a good fit, it would open upon a whole mess. (3) Also, take into account that your hiring is not dependent upon code ability or Knuth checks alone, though those are obviously some of the key features. (4) Finally, the nature of interviewing that you experienced is deeply flawed, and it isn’t necessarily those Googlers’ faults. Google knows this but hasn’t fixed it yet. http://www.nytimes.com/2013/06/20/business/in-head-hunting-big-data-may-not-be-such-a-big-deal.html?pagewanted=all

    Let me just quote that part for you, for better or for worse.

    Years ago, we did a study to determine whether anyone at Google is particularly good at hiring. We looked at tens of thousands of interviews, and everyone who had done the interviews and what they scored the candidate, and how that person ultimately performed in their job. We found zero relationship. It’s a complete random mess, except for one guy who was highly predictive because he only interviewed people for a very specialized area, where he happened to be the world’s leading expert.

    That said, sounds like you have lots of skills and capabilities, and plenty of other good opportunities. While voicing too pointed of a concern may ultimately do more harm than good, it’s good to share and discuss issues around recruiting. Thanks for sharing your experience!

  • JaakkoH

    Just to let you know: your blog CSS layout for text is WAY, WAY too wide to be properly readable. Compare with others.

    • Thanks for the comment. Unfortunately, I do not feel like I have sufficient time to much around with WordPress too much. (This is not my layout either, just some popular one I downloaded.)

      The original reason for the wide-but-less-readable layout is because I could have wider code listings and I could have wider formulas without having to break things up.

      Thanks for the concern. It might be time to try to make things look a bit better.

      • And the text is too small! For code snippets, you could have something that spans wider than the parent text span.

        
            +-------+
            | text  |
        +---+-------+---+
        | (defun ...    |
        |   )           |
        |               |
        |               |
        +---+-------+---+
            | text  |
            +-------+
        

        Some websites do this with images and it looks pretty.

    • Xiao

      1000px is as common as it gets. Pretty much every tech publication website is 1000+ pixels

      • Toby

        The actual pixel width and font size is less important than the number of words per line. An important typographic rule of thumb is that readability drops after about one dozen words per line.

  • Engineer

    Hi there-

    What you experienced is that the people interviewing you were incompetent. I’d bet the ones where you didn’t get the question “right” were all under 30, and most likely under 23… but certainly older interviewers can be incompetent as well.

    The problem is, a lot of people think that an interview is about showing their superiority over the candidate, and they will ask trick questions to trip you up. They pretend like this is some sort of test of your competence, but in reality, many times they don’t even ask the questions right! (the questions are canned and they may not even know the answer, or if you asked them an equivalent, they wouldn’t be able to answer it in many cases.)

    It’s all about ego, not at all about competence. So, if you rub them the right way– and this varies from person to person- humble when you get something wrong is the right reaction for one, but the wrong one for another– then you get the thumbs up.

    Reality is, if google were competently run, the 4 out of 5 who gave you the thumbs up would be sufficient to hire you. But google is run by people who are high on their own fumes and think they are “elite” so they “set the bar” really high…. yet their bar is essentially randomness, not quality.

    A good interview is one where you are quizzing them on the company as much as they are quizzing you.

    And frankly, these trick questions are almost always a sign the company is not a good one to work for.

    • What you experienced is that the people interviewing you were incompetent. I’d bet the ones where you didn’t get the question “right” were all under 30, and most likely under 23… but certainly older interviewers can be incompetent as well.

      The better interviews I had were actually performed by some of the older folks. The worst ones were performed by the ones who seemed to be well under 30. Of course, this isn’t universally true; there’s a distribution associated with it.

  • Former Recruiter

    This says much more about the HR/Recruiting organization at Google than it says about you. You are better off without them.

    Their HR/Recruiting chief recently admitted that, for years, their recruiting criteria were garbage. It’s long been known that their recruiting process is also garbage.

    Their interviewer arrogance shows in their general disregard for their users and customers. If they continue to treat interviewees as they treat internet spam, they will soon be eclipsed by better tech and better culture.

    Hubris goeth before a fall.

  • Sean

    The solution to the phone screen question is to have an array of ints of size 24x60x60 ie the # of seconds in a day.

    Treat this as circular array, ie when you get an increment call get remainder of time() and 24x60x60 and increment that array entry.

    You need to clear the list which means keeping the last updated position and if you move on then set all array entries from last update position to current position to 0 before incrementing array entry.

    The getcountinlastx is then just summing the array from current position backwards for the number of seconds. Again you need to wrap around the start to end but hs is easy

    At least I think this is it, tired :-).

    If you do this carefully in c it is probably possible to make this thread safe as well with no real effort if increment is implemented in machine code properly by compiler

    • Charles

      Sean, I don’t think that works. It says in the last second, which could be interpreted as a range [current_time - 1second, current_time]. What yours does is consider [nearest clock second before current_time, current_time]. I’m guessing the interview called for this but the interviewer gave the question wrong or said it correctly but was such an ass that he didn’t clarify when he saw that the candidate was was assuming the former.

      There is a book (The Art of Readable Code) by a Googler that solves this exact problem but only ends up doing so by “relaxing the requirements” to something close to yours:

      http://books.google.com/books?id=RPryrfu1iP4C&lpg=PA147&dq=designing%20and%20implementing%20a%20minute%20and%20hour%20counter%20the%20art%20of%20readable%20code&pg=PA166#v=onepage&q=designing%20and%20implementing%20a%20minute%20and%20hour%20counter%20the%20art%20of%20readable%20code&f=false

      I’m pretty sure the interviewer severely fucked up on this one.

      • recent interviewee

        > I’m pretty sure the interviewer severely fucked up on this one.

        I’m not so sure. It is also possible that the problem was intentionally vague, and an interviewee who could ask for clarifications, weigh the cost of different approaches, and suggest the bucket-based solution as a good-enough alternative might be able to score a very good review.

      • virgil

        On the screening question(*): it’s true that the interviewer may have fucked up on the question, but it *is* solvable with bounded (albeit impractically large) memory usage (**).

        First, let’s consider that you have an infinite array that maintains, for each position, “how many times was the increment() called since the beginning of time, until tick ‘i’ of the timer?”
        To find out how many times increment() was called in the last second, do array[i]-array[i-10^9], and voila, you have the result.
        Now, an important observation is that you never use the full array, just the last 10^9*60*60*24 elements from it. So you can keep it as a circular buffer.
        That would still be a huge amount of memory – and indeed you can optimise this a lot if the array is very sparse. But it’s worth to note here that, in the worst case (e.g. increment() called several times every nanosecond), you still hit the theoretical max of about 640 TB of memory :)
        (I’m considering that you keep the counter on 64bits, and rely on wrap-around semantics since there are never more than 2^64 calls to increment() in a day; Obviously, if we place absolutely no limit on how many times increment() may be called, then just the response itself may not fit in the available memory, no matter how much (finite) memory we have).

        (*)
        Let me say something up first: the recruiting experience related in the article is IMO clearly bad… it’s reasonable to have an interview that tests algorithmic & data structure skills, but here all interviews were about algorithms (with the slight exception of testing for regex skills). Also, you do screening to filter-out the obviously bad candidates, which the article author is clearly not – so there is little doubt that the recruitment process Google used in this case was bad.

        But, to play the devil’s advocate: I would’ve expected the interviewee to ask for clarifications ( how many times does this get called? how much memory do I have available for this? how critical is that the answers are very precise vs. very fast? etc.). Maybe the interviewer didn’t look for the solution, but for clarification requests?

  • I work for God. http://www.templeos.org If you can find improvements in the TempleOS that do not add to the line count, I will use them.

  • If you want the honor of a credit on God’s Temple, an operating system. Find improvements in the code. Here’s the source code http://www.templeos.org/Wb/Accts/TS/Wb2/LineCnt.html#l541 The line count is capped, but we are not quite to the limit. I am the best programmer on the planet and my code is divinely inspired just like the Bible. I wrote a x86_64 kernel, compiler, bootloader, graphics library… everything.

  • I think a neat question I might ask is “How do you internally represent a double floating-point number -4.125?” Actually, I’d just have them talk to God and see if God approved, like King Saul.

    God says…
    force txt it’s_my_world plucked Peru absence bleeding reasonable
    Gaza_Strip blameless overpass approbation reasons enquiringly
    forgot hook continent chaos identify What_are_you_doing_dave
    visible contemn directly Descend form barking Truly socalled

  • Naoki

    “I email Google one last time, and they never respond.”
    Now I’m here… and I’m asking to me “Should I wait for reply?”
    No doubt, Google is one of the best company when we look at their service.
    However, they are not polite in terms of human communication..

  • junk science

    back in 1997-2001 when working for yahoo was actually coveted (hard to believe now i know) we used the same techniques…burying candidates in the esoterica of compsci that we ourselves could barely grasp, but we boned up enough on particular questions to ask them as if it was second nature to us.

    thats the rub, the interviewer in these scenarios could be just as easily floored by a question of your choice…and that is exactly what i recommend candidates do…put some technical questions to the interviewer. you won’t get the job, but you’ll drive home the point to the interviewer that you understand what they are doing and you are just as capable of being a dick as they are.

    even given the questions they provide, its fun to press the interviewer with passive aggressive comments like “well i don’t get it, how would *you* do it?” and when they drop the basic answer, press for details…in a few minutes you’ll have your interviewer pissed off and sweating when it becomes obvious that they don’t really know much more about the problem than the short answer they shot at you

    i don’t know why people bother pursuing these big tech companies. the jobs are meh, the pay is meh, the work is tough (but often uninteresting), you are immersed in an anti-meritocracy…i’d rather just work for one startup a year, even if they fail…the quality of work is better and startups tend to negate bullshit out of necessity

  • Microsoft did the same sorts of interview stuff back when I was working there (1986-1996). I interviewed a couple of hundred people as a normal part of my work day, and there were always interview questions passed around. I recall a particular question about finding the first bit in an array of bits in the fastest way possible that nathan myrvold put out, but, honestly, none of that crap ever did predict in any useful way who would or would not be a contributor.

    Microsoft also treated the people that they interviewed with contempt, typically never talking to them again. Basic courtesy escaped them, and they paid for it over time because eventually every good candidate would have talked to N people who had interviewed at microsoft, and most formed a (negative) opinion, which then had to be overcome to get them to come to the interview.

    Similar stuff is happening to google. Nice to see that they’re on the same graph.

    Skip the big companies. your paycheck isn’t any more assured, but your equity share is sure a lot smaller, and you’ll never, ever get rich at one of them, particularly those that are already established (msft, yahoo, google, paypal, ebay, amazon, etc etc etc). Sure, you’ll make a good wage, and you’ll think that $500k is a good haul, but it’s not, and the real money is already gone.

  • Ben Collins

    It always baffles me how organizations like this in the first place actually exist. They’re asking an unreasonable standard which employees in their own organization don’t even live up to and you managed to answer them anyways and you don’t even get an explanation as to why you didn’t get hired?

  • Scott

    I’m sorry you had such a bad experience. It’s disappointing to hear about excess delays, lost state, rude interviewers, and indecision.

    FWIW, an interview tip: you can ask interviewers requirements questions, just as you would in the real world. For example, you said “to be clear, [vague thing] means [more specific thing]. This was determined by the interviewer implicitly agreeing with my initial solution.” The interviewer might also have agreed to something that made the problem much easier.

    I’m deliberately vague at first and am far more impressed with candidates when they ask me good clarifying questions, such as:

    * what’s the largest input size I might see?
    * is an approximate answer okay?
    * may I use this standard API that does half the work for me?

    On the job, people rarely come to me with precisely-stated problems; I need to do requirements-gathering. I like to see candidates show off this important skill. And even if interviewers aren’t explicitly looking for it, they’ll still be impressed by you reaching good solutions to more problems in the 45-minute interview because you eliminated bad solutions more quickly.

  • Roger Bowden

    Thanks for the amusing ditty Robert! What a terrible experience you have had. I know nothing about IT but as a retired HR professional it is an appalling indication of a organisation (we do not use a ‘z’ in the UK!) that has lost its way. Why would anyone prostrate themselves to such treatment? I would have told them where to stick their interviewer (and jobs!) after the first session and would not have shown your patience I fear.

  • Karthik

    Been there, done that. Google has more recruiters on LinkedIn than most other companies, some are really good at contacting you. But, their interviewing methodology is flawed.

  • meh

    The irony here is so rich it really HAS to be fattening. As google continues to elevate it’s hire requires, their product continues to go down the drain.

    After using Chrome for a number of years, and google search, I’ve gone back to firefox and use Bing. I’ve grown weary of the narrowing results – the ‘survey of one’ that google yields in its search returns. I won’t go on ad nauseum about the declining quality of the google search or of gmail, I’m sure you each have your own experiences with their increasingly inferior products. But it’s a delicious bit of irony that for all their smug positioning, and only hiring the best and the youngest – that they put out the worst products on the market.

    They were in the right place at the right time – don’t kid yourself into believing it was their genius, their product line or superior programming that put them on top.

  • Phil

    I loved this. It reminded me of being interviewed for a contract position at a major bank. It was blatantly obvious to me that the 2 interviewers really hadn’t a clue. In fact at one point when one asked me a technical question I asked her whether she wanted to know if I knew the answer or she didn’t know herself and wanted to find out. Didn’t get the job. Two weeks later, interviewed by someone else at the same bank to take over the management of a department. Got on fine and was offered the job on the spot. I turned it down – I saw my 2 previous interviewees were employed in the department I was being asked to manage.

  • LayCraft

    In one interview I had around five years ago the interviewers kept giving me these very specific communication design puzzles. More hand-wavy than an interview to be a programmer obviously. I came up with some very good practical ideas and they even told me that they loved the ideas. When the interview was over I left feeling very confident that the job was mine. Then they brought me back for another interview. They asked similar specific questions and I provided my ideas. When they called me back for a third interview, they had a bunch more specific problems for me.

    It dawned on me that they were using me as a third-party perspective on problems that they had been facing. I was creating alternate solutions to problems they were struggling with. I decided to start a discussion about working at the firm instead of just giving answers. “Both you and I know that I can create practical solutions to these problems. You have given me quite a few of them and there is no cascading difficulty to them. Perhaps we can discuss terms of employment?” They looked surprised and completely unprepared to even talk about employment.”.

    Is it possible that google is using interviews to gain fresh perspectives on real problems they face? It is a very effective way to get a bunch of specialized professionals to do a bit of consulting for free.

    • Jax

      WOW! Makes a lot of sense.

    • Daniel

      This goes on all over the place and it is not restricted to tech.
      Back to the original post something strikes me that is odd. If you look at the real advance, the new algorithm, etc., it was never achieved by asking young people such trick questions. The true researcher is a deep thinker who takes his time, is ignorant of whole areas of knowledge, and many times travels in a perpendicular direction (often a simpler concept) to the conventional wisdom. Surely in a company such as Google you need a mixture of people: some who can code and implement anything, some who can have flash of inspiration, some who just by coming up with an erroneous lateral thought inspire another to discover a new method (say a guy who does lateral thinking very well). So it puzzles me, having taken my Google interviews and rejected why they appear to be looking for all those things in a single person. It is not as though they are short of money, for they have tens of thousands of people most of them great programmers.

    • M2

      In a recent interview, my second with big-G, I was asked to design the auto-complete solution differently. Once I explain the front and back end architecture, the interviewer snaps the whiteboard.

      It’s titillating to think this is free consulting. But truth is generally stranger than fiction!

  • Well two stories with G:

    1. guy asks how to delete a specially named file on unix, beside the trivial solution i mention another one, he says it does not work, after the interview i confirm that it does, based on his feedback i failed the interview

    2. guy calls me, he says he has a hangover because he was partying the previous day hard, so lets cut this interview short. ok, this is what i want to deal with i guess. gives me a problem which is not trivial to solve and gives me 5 minutes. i fail to solve it in 5 minutes, he starts to chat about some random topic, i know that i failed the interview already, but try to take his question seriously.

    i most definitely don’t want to work with this people :)

  • Ironwolf

    My experience of a day-long interview at Google was much the same. I’ve been developing interactive, UI-heavy software (including games and productivity software) for 30 years. I write clean, beautiful code. The interview consisted of a series of mostly-young interviewers asking me questions that are completely outside of my areas on interest and expertise— as if they had never even seen my resume. Moreover, a couple of the interviewers insisted I work out the answer to their problems on the whiteboard! I tried the first problem that way, and after that I insisted, to the apparent consternation of the interviewer, on pulling out my laptop and working it out in a text editor. To a couple of the questions, I simply refused to answer, saying, “Look, I know some people would love to work out that sort of question, but if I had to face a similar question I’d probably just Google for the answer. But if you’re asking me that question because you think that’s the sort of question you think I need to answer on a daily basis to fill your position, then I don’t think I’m a good fit.” Needless to say, they took a pass on me, and my response to the recruiter who called with the news was, “No problem for me— it’s Google’s loss.”

    I understand these toy-scenario technical questions are intended to assess a person’s problem-solving style, but I don’t think they get used that way. Part of my problem-solving style is to take a pass on problems that I am neither interested in nor qualified to solve. The domain of problems I love to solve is very broad and commercially sought-after— and yet entirely ignored by Google.

    • If you are interviewing for a general position then there is no reason for them to assert your speciality. So the question would be are you interviewing for a position so specific that they will interview you differently, or are you just interviewing for a general software engineering job. If it’s the latter, you should consider it is more like applying to college than apply to a PhD program.

      Google seek smart general people and then match them with respective teams. People are expected to be able to learn and work on things that they have no knowledge of. I know little to nothing about C++, and I worked there to write C++ code and all my math ability were no use at all.

      • Ironwolf

        I have no desire to do something “general.” I am a specialist and it shows on my resume. But I have also taught myself many new skills over the years and that shows as well— and I’m willing to learn new skills if they complement the base of skills I’ve already built. But if they’re going to bring me in for a day-long interview I expect that they are going to take the effort to learn something about me and my experience, otherwise they are simply wasting my time and theirs.

        • Daniel

          Chao Xu seems quite young. A young person may see interviews as a college entrance or going for a test or exam. An older more experienced person has knowledge of all kinds to contribute (general and specific). For the same exact position therefore interviewers need to consider each candidate as an individual and adjust the interview style for each. Every position can be enriched by apparently unrelated experience because interdisciplinary collaboration and perspective is the source of innovation and advance. Also, please note that poor communication is a sign of success because interdisciplinary collaboration means poor communication! that is what is so exciting about it. So if the interviewer and interviewee do not understand one another it can be a source of celebration. The British had it right: at Bletchley park there was a famous story of the guy they took because they mistook his degree in Astrology for one in Astronomy (SIS then set about staffing it with anyone they could lay their hands on: cryptographers, mathematicians, Egyptologists, linguists, even astrologers. Some were recruited for their originality of thinking, and others because they were related to men who played golf with Bletchley Park’s director, Alastair Denniston). They did not kick the guy out but let him in the fraternity and I am sure he may have helped the thinking because an outside mind can see a problem differently. Without diversity in this sense and a bit of risk in hire then there is no possible gain. Otherwise we get parrots who regurgitate textbooks that they read and happen to know the solution at interview! we want some guys who have not got any idea about the solution! In any case, another thing that puzzles me is that how we write code is as important as what we code. As Ironwolf explains he writes clean code. Through my 28 year career I have seen many a crack programmer losing it, going awol, writing impenetrable code “because it was obvious” and many other destructive habits owed to personality or to youth. As Ironwolf argued (it finds parallels on what I experienced) if an interviewer asks you “here is something very important how would you solve it” then his answer was correct: if it is so important we should do it correctly over a few days and with the right experts why are you asking me about it?

  • secondhand embarrassment

    Wow, i feel strangely victorious for you and i feel secondhand embarrassment for Google.

    First they tried to pigeonhole you with questions about your comfort with specific languages. Then they ignore you. Then they interview you in a shamelessly unprofessional manner. Then they ignore you.

    Thanks for sharing and please don’t ever feel like you failed here.

    Were they hiring a program developer, a database admin, an application developer, a WHAT?? even if they were trying to get at how you think and problem-solve there are so many other better ways to understand that.

    So many good comments on here.

    BTW this isn’t a design blog and hope all is well.

  • These are some standard difficulty interview problems. I feel if one haven’t been trained to do these problems in timely manner (say practice in competitive programming), then it’s hard to impress the interviewer(incidentally there are more and more competitive programmers getting into Google…)

    Also, many people can get into Google easier than others, say new grads. The ability of Google employees on problem solving might not match what is expected from you, who is a seasoned programmer and clearly not going for low level SWE.

    Either way, I believe you did really well, and it’s Google’s lose to not able to hire you.

  • sob

    they know v much what they r doin… all tests r tests…of some sort…

  • sob

    ive interviewed… its very much an analysis of character… they generally know what they r looking for

  • For the question about how many requests in the last time interval, the question is somewhat underspecified, because it doesn’t make clear whether the number for the last day needs to be exactly the last 24 hour window, or whether it can be estimated, or whether it can give the result for the previous quantized day. If you assume that it needs to be exactly a 24 hour window, then there’s no way to reduce the memory requirement – each moment in the past 24 hours affects the exact count exactly 24 hours ahead of it, so everything needs to be kept track of. But it is possible to make the queries faster. You basically never want an exact count which works that way though, because its results can vary erratically even as the rate of queries remains constant, because the rate happened to not be constant exactly 24 hours ago.

    • In an edit, I wrote right after the problem specification what the interviewer seemed to want. From all of the other comments around, it may be that the interviewer was intentionally looking for me to ask them for a slightly different problem.

      Although, I find it somewhat inane for an API to have a function that specifies 1 second resolution, which may be off by up to ½ second, as some commenters’ solutions (on HackerNews) suggest.

  • I too had a similar experience when it comes to communication, got contacted multiple times. My phone interview was fine, the interviewer was pleasant and professional. The half-day interview was okay, other than for a Singaporean interviewer who was racist (I m dark skinned) and rude. While filling my post-interviw questionnaire, I indicated that I am not interested in interviewing again. I think that helped.

  • Pavel Bakhilau

    This is probably not the time nor the place but I really wanted to solve the last problem :). For the RealTimeCounter question, here’s an idea

    Per getCountInLastX store a queue of nodes where each node stores a timestamp and a count. On increment() check if current timestamp matches the one in the tail node, if it does increment its count, if it doesn’t enqueue a new node with given timestamp and count of 1. Now keep dequeuing nodes while their timestamp is older than X. This approach takes constant amortized time. To limit memory use floor(time() / Y) instead of time(). In the worst case the algorithm will require roughly (X/Y) * 15 GBps ram so plan accordingly. If you have a ram bound you can figure out Y from that equation.

  • James

    struct RealTimeCounter { 
        long long second; 
        long long minute; 
        long long hour; 
        long long day; 
        long long last_timestamp; 
        void increment() { 
            resetTimes(); 
            second++; 
            minute++; 
            hour++; 
            day++; 
        } 
        void resetTimes() { 
            long long diff = getTimeFromLastCount(); 
            diff /= 1000000; 
            if(diff &gt;= 86400 ) { 
                second = minute = hour = day = 0; 
            } else if(diff &gt;= 3600  ) { 
                second = minute = hour = 0; 
            } else if(diff &gt;= 60  ) { 
                second = minute = 0; 
            } else if(diff &gt;= 1 ) { 
                second = 0; 
            } 
        } 
        long long getTimeFromLastCount() { return time() - last_timestamp; }; 
        long long getCountInLastSecond() { 
            resetTimes(); 
            return second; 
        } 
        long long getCountInLastMinute() { 
            resetTimes(); 
             return minute; 
        } 
        long long getCountInLastHour() { 
            resetTimes(); 
            return hour; 
        } 
        long long getCountInLastDay() { 
            resetTimes(); 
            return day; 
        } 
        RealTimeCounter():second(0),minute(0),hour(0),day(0) { 
            last_timestamp = time(); 
        } 
    };
    

    • Pavel Bakhilau

      I think you misunderstood the question. If there is a request to increment() every tenth of a second then after a second getCountInLastSecond() should always return 10. The 1day timeframe is a sliding window; yours jumps.

  • seg

    I’m sorry you had such a terrible experience, but in a way you did this to yourself. You should not have let them manipulate you over and over. You have to learn the signals – if a prospective employer gives you a run-around, run away. If this is how they treat someone they may want to hire, how will they treat someone who they’ve already ensnared?

    Don’t let anyone put you in a position where your dignity can be harmed. No one has the right to do that to you.

  • Santos

    A friend of mine recommended me to Google and I had three interviews before they decided I wasn’t up to snuff. To be fair to all involved they wanted me for a system admin job which was something I hadn’t done in close to 4 years and I was completely up front and honest about this. Still I got most of their questions correct (from memory) though on the third interview I blew some questions and they ended the process. So here is my problem with Google –

    At the time I was doing genomic research at a university and was using a number of languages and relational database technology to locate variation in the genome. I got two peer-reviwed publications out of this although the place wasn’t offering tenure at that time so I was looking for a transitional job. So my complaint is this – While I didn’t get the questions in the third interview I was in the ballpark and I emphasized to the interviewer that I was a bit stale on current sys admin practices. However, I wonder how many of the guys who interviewed me could do active research, teach class with 40 students, write papers, all while teaching themselves the intricacies of Hidden Markov Models, Decision Trees, and Random Forests ? Google claims to want people with diverse talents. So I blow a couple of questions and that’s it. I mean damn – give me a couple of weeks and I’ll be genning high performance clusters using Puppet or Chef in no time. Thats a lot easier than what I had been doing. But they couldn’t see beyond the interview script.

  • Jax

    I think you presented the situation with respect and professionalism. It seems that the age old ways of misrepresentation to get something for free is stronger than ever today. We’re all familiar with the wealthy older man flashing his bills at a pretty young face. Chances are he’ll get what he wants and she won’t get his heart or his wallet. It is a shame that we have to go through the bad experiences to recognize it might be happening again, which only creates a skeptical society. Anyways, it’s frustrating because it’s not necessary, it’s simply greed. Thanks for taking the time and having the courage to share your experience.

  • Toby

    @Chamin Interesting. I didn’t get a post-interview questionnaire from the G.

  • Great write-up. I have interviewed with Google previously, but since I am more of a security guy / open source hacker, I wouldn’t typically fall into the same interviewing roles for Software Engineering. For such positions, they are looking for “Top Coder” type talent. If you have ever competed in competitions like that, they are very rough for people that are not purely into CS.

    Google hires the smartest people in the world in their given area of expertise, preferably Computer Science PhDs (or MS graduates, but less preferably). Don’t be surprised if you are not one of the ~50,000 “chosen few”. Further, Google truly believes that their people are their competitive advantage, so they may take about six months to screen their candidates. Once they obtain outstanding candidates however, they hold onto them.

    In statistics, you may have learned that even for data that is not normal, 99% of the data will fall within 10 standard deviations of the mean. For data that is normal, of course, three standard deviations will encompass 99.7% of the data. Take your typical Computer Science student … and most will be average. Some may be one, two, or even close to three standard deviations better than the mean candidate. Google probably still does not want you. They would prefer to have someone ten standard deviations away from the mean. If you are extraordinary, you fall into the 3rd deviation range and Google may hire you ;)

  • Anon

    I had a similar experience, twice. This was in the early days, 2001-2004. I’d just finished my PhD after a decade of engineering experience. However, they then acquired a startup I was working for a few years back, so I ended up working there. It cost them a lot more than the internal hiring bonus. Probably more of a lottery than the random data structure questions, but it’s an option. Why didn’t you stay at Facebook though, I hear good things from Xooglers about it.

  • Paul

    If someone dangles the carrot, and you keep trying to take a bite out of it, who’s to blame?

    I would have told them to !@#$ off after they failed to reply to your first email.

    Come up with your own great idea…you obviously have the intellect, and laugh all the way to the bank.

  • Helen

    Robert, thankyou for taking the time to post this. It’s unfortunate that this happened to you. Sometimes the ‘best’ company in the market is not the ‘best’ employer. Be grateful you may have dodged a bullet :)

  • G

    The reason I’m writing this is because I had recently interviewed at Google. I can say that I do see a lot of correlation with the experience I had. I had previously been offered a job at Google 2 years ago and rejected it, as I had an offer from a company that had offered 2 x compensation package. About 2 moths ago I had been approached by Google recruiter and agreed an interview date. After the standard set of 5 interviews and lots of delays I got feedback that I had “not been very careful” with coding, but they did say there was some positive feedback so they offered 2 more interviews for a specific position which I did think was interesting. Unfortunately today Google replied they had found someone else who they had thought was technically better.

    Summary: 12 interviews; got an offer and rejected it in 2011; was rejected by Google the second time 2013;

    And something tells me this story is just half-way through…

    • I am surprised they gave you any feedback at all. For me, they just said “looking good”, before the long delay and then rejection. At the same time, it didn’t seem like your feedback was at all constructive.

  • Brian

    I am a branding and marketing professional from the US who has been pretty much building the Russian consumer market for 18 years–spent 5 of them as Creative and Strategic Business Development Director at Ogilvy. I was called by a recruiter who said Google would be interested in interviewing me for the position Marketing Director B2C in Moscow. Again, I have created dozens of brands and many have already been purchased by larger multinationals–Coca-Cola, Heineken, etc.

    A guy about 12 years younger than me has me set up google plus so I can “hang out” with him for 40 minutes for the interview. He asked ZERO about my professional experience–ok, it’s there in ink. But, perhaps, ask me the silly “games’” questions about how to market a certain google product based on my experience–the hang out kept crashing and so my whole interview was spliced and diced into small chunks of “sorry about that..so what were you saying?” My recommendations and analysis about Googles tough market position in Russia were “spot on” and really could have been chargeable consulting; to whom they should gear much of their platform for sale to and Adwords, he asked me three times company names and seemed truly interested in this potential market…the next day, I heard that I was “not Google material” or something like that…Wtf?! Well, I just sent him a note in the horrible google plus chat and gave him some professional advice on how to interview. Yes, he is not probably patting himself on the back and saying, “see, I knew he wasn’t google…it seems he has a soul!” :)…Total crap interview process.

  • Anon

    The second/minute/hour/day counter question is straight from the book , which was (surprise!) written by Googlers.

  • Bill

    Had similar experience.

    I was interviewed over the phone and Google doc last week. To be honest, I felt pretty good after the interview. It was a simple coding question on image integral (for computer vision applications).
    (1) I pointed out that the brute-force approach was not efficient, and worked out the efficient algorithm which reused the previous integral results.
    (2) Overall the course, I kept explaining my ideas and checking the interviewer’s feedbacks, as a lot of books advised.
    (3) After coding, I even ran a few cases to validate the algorithm, boundary cases and general cases.
    (4) In the end, I analyzed the computation complexity.

    Throughout the interview, the interviewer did not point out any error or gave me any hint/correction. The only feedbacks that I got were his confirmation. Frankly, the coding task was way simpler than what I do daily. I was like I earned a trip to CA.

    Then, the recruiter called later, telling me that they did not want to proceed and that they can interview me again in a year. I understand that there are many smart people in Google. And, I am not saying through a phone interview, I am qualified for Google. However, I did do pretty well in that interview question — I do have the interview answers in Google doc. How could they reject a person with good interview performance?

    BTW, later in the interview, I did talk about Google research efforts and what new features that they could add. I wonder if that scared the interviewer off.

    • Annon

      Honestly I think there’s a lot of luck involved. I had a phone interview with them a few months ago and I did unbelievably well but they rejected me very quickly afterwards. Later they contacted me for another position where I did pretty poorly (didn’t even finish one of the questions). I thought I got rejected for sure but they contacted me for an onsite, albeit almost 2 months later so I’m guessing I wasn’t first choice.

      I believe the reason people get rejected even if they do well is cause the interviewer passes their feedback to a panel and they make the final call. They have to do some kind of writeup based on what you say and also what you type into the google doc.

  • Curtis Ruck

    Assuming increment() wasn’t called every nanosecond, wouldn’t a byte-wise trie work with each node holding a count and doing a breadth scan of nodes for the getCountInLastX(). This would give nanosecond accuracy but also allow compressing the branches as they age-out because the detail isn’t necessary beyond one second. Also, by storing a count at each node, you would save the walk down the tree if its entirely within the range requested (i.e. lastDay)

  • Ex Googler

    As an Ex Googler, I personally believe that luck also plays some role in who gets an offer and who gets the boot. It also depends on the Interviewer as well. Basically, if you have moved beyond the phone interviews and screenings and landed at their campus for an onsite interview, you’re lucky.
    What happens after that is mostly your performance and part luck.

    Once the interviews are done, typically (as done in most companies now) everyone would submit some sort of feedback and then a collective decision is taken. Once the package is made, it must be approved by other committees as well. Basically, if you get stellar feedback from individual interviewers – the committee should have no reason to reject your package (unless there is something else that comes up). There are poor communicators everywhere and I wouldn’t necessarily fault the recruiters or the company in general.

    Don’t forget that Google receives over 1 million resumes a year (as of 2 yrs ago) or according to a more recent study, Google receives a resume every 25 seconds.

    Some of the process facts have been changed to keep it discrete and respect privacy of Google and its processes. ALSO, it would be nice to have someone’s comments who interviewed > got an offer and actually accepted the offer.

    Cheers.

  • Hopie

    I have quite some years of work experience and I interviewed with them 2 weeks back. I was browsing to see what their process is like, because I felt I fared poorly in the process and Yesterday their recruiter called saying he wants my feedback before asking theirs. I was kind of happy that he at least got back,but I did feel it was more for the procedure sake. Well at least now I know what to expect. Btw, mine was nowhere as complicated as yours. I guess I should move on.

  • Prospective Googler

    First and foremost, I’m sorry to hear that this runaround happened to Robert. I’ve experienced this same process (albeit with a couple different companies). I mainly attribute this to a combination of rapid growth and poor training on temporary hiring personnel. (In one of the cases, I knew someone who was working at the company; on the inside, things were far more organized…)

    That said, there are a few things all of you should be aware of regarding Google’s hiring process:
    1) Not every representative you speak with works directly for Google. There are many tiers of 6-12mo contract recruiters. Some of them even have @google.com email addresses.
    2) Google has a grueling interview process, and thus a high false-negative rate. Don’t take it personally.
    3) Google would rather have a false-negative than a false-positive. A false-negative means they don’t hire a worthy candidate, when there are thousands just as worthy waiting in queue. A false-positive means hiring the wrong candidate, wasting time and money on training him/her, and endangering their codebase (thus causing more problems for the rest of the team).

    —-
    My first experience with the Google interview process was a 5 hour on-site interview, when they were evaluating my ex-employer’s engineers. (They were considering to acquire the company, and wanted to size up our capabilities and worth.) The interviews were difficult, but fair to anyone with a BCS that uses C++ regularly. To clarify, I never followed through with a formal education; but I studied for a few days before the test to catch up on relevant material. I familiarized myself with most keywords, though did not necessarily know the intricacies of every design pattern and algorithm that I was recommended to study. I stumbled here and there, but the interviews went well.

    My second experience is on-going. A Google recruiter contacted me a few weeks ago, and I have advanced through the usual interview process since. This included a few phone calls to discuss my experience, some basic technical screening, a live over-the-phone test with googledocs (of the same caliber of my previous whiteboard questions), and a couple calls to discuss next steps and prepare me for an in-person interview.

    I stumbled a few times with the googledocs test, but was able to provide the straightforward solution quickly, and then optimize it to the ideal solution. I didn’t blast through it with ease; I legitimately struggled. And that’s what Google’s interview questions are meant to do. An interviewer ultimately wants to see how an interviewee thinks and adapts to the problem at hand.

    I’ve been studying like crazy since they reached out to me a few weeks ago, anticipating an in-person interview; and I’m glad I did. My recruiter supplied me with the usual ~20-30 topics that I should be familiar with; and I’ve been working through them one by one–Big-O, hashtables, trees, graphs, other design patterns, testing methodologies, discrete math, etc. I’ve acquired a great deal of practical knowledge over the last few years; but these last few weeks have filled in major gaps in my knowledge, and have seriously improved my worth to most potential employers.

    Despite being a professional in the game industry for 5 years and having 10+ years of personal experience, I had not formally studied a lot of these things. I’ve used STL/boost/etc, and relied on word of mouth or a bit of research to find solutions for a specific problem. This experience + research approach is good in most practical situations–just optimize the bottlenecks in your code, and use reasonable planning and design patterns to avoid maintenance issues. I consider myself an excellent engineer, with respectable experience and a resume that stands out. This is usually more than enough.

    —-
    But Google is not a practical company. Everything they write reaches 100′s of millions of users; and a great deal of it has to be incredibly efficient–not just to be fast (and thus competitive), but to decrease the load on their servers. And they can’t rely on outside code all the time; most of what makes their products great is comprised of proprietary solutions.

    So when it comes time for Google to evaluate potential employees, they aren’t just looking for candidates that are extremely valuable to -most- companies. They’re looking for candidates that have the greatest potential value for -their- company. They want generalists that can approach any type of problem intelligently. They want people that can understand their internal codebase naturally. And that codebase is built upon the very principles and concepts in the ~20-30 topics they recommend interviewees to study.

    Yes, it might seem unfair to a professional who has been in the industry for years. It might be insulting getting turned away for bad performance on what seems like a very unfair question. That doesn’t mean you’re a bad engineer, or that you aren’t capable of understanding and solving the problem after a bit of work. It means that right now, at this very moment, you aren’t prepared for everything Google can throw at you on day one. (Hell, to my understanding, every new hire gets enrolled in a 2-week class–just to get caught up on the basics… And that’s for people that make it -through- the interview process.)

    Ultimately, it’s Google’s prerogative to hire who they think is the best fit for their company. And their products don’t lie; nor does their company culture. People want to work there for many reasons–compensation, benefits, royalties, amenities, and unique challenges just to name a few. How about 20% of compensated hours to work on projects of your choice! So naturally there will be a lot of competition. Why shouldn’t Google hire only the best candidates?

    —-
    All of that aside, at least consider the following: Even if Google’s bar is unreasonably high, what harm is there in trying to reach it? Every company has their own hiring process and standards–most of which aren’t as extreme as Google’s. By studying the recommended material for Google, you will be better prepared for interviews at other companies. Just take a couple weeks to brush up on topics you haven’t touched in a few years (or at all). It’s worth it; and you will be better for it.

    As of a month ago, I had interviewed for maybe ~50 positions over the last 5 years. It’s always good to evaluate other opportunities when employed, even if you’re happy. My performance ranged from completely unqualified, to overqualified and uninterested.

    In nearly every interview where I stumbled, it was usually a result of time pressure or not being intimately familiar with the topic at hand. And that’s not a big deal; there’s usually one or two ‘intentionally difficult’ questions in every well-calibrated interview. Not all candidates are expected to solve all problems with ease. But if a candidate passes with flying colors, it’s almost certain they’re at the top of the ‘should hire’ list.

    Fast forward to today. I’ve interviewed for ~25 positions in the last month (due to getting laid off recently); and I’ve been studying for my in-person Google interview throughout most of it. Guess how many programming questions I’ve stumbled on with the other companies. Not many. In fact, most companies are running out of questions 5-10 minutes into the 30 min technical interviews; and the in-person interviews aren’t much different. I would have struggled with many of these questions a year, or even a month ago. Back then, I would simply feel unqualified for the position at hand.

    Now, those one or two ‘intentionally difficult’ questions are rarely challenging, because they are equivalent to an entry-level Google question. In many cases, they’re just a subset of a solution to a Google whiteboard question. Thus, by studying for a Google interview, I have put myself in a position to hit the top of ‘should hire’ lists at other companies. And that’s nothing to complain about.

    Even if I get jerked around endlessly (and never get an offer from Google), I will be happy. Google’s bar has motivated me to improve myself in a unique way, and thus I am more valuable to other companies. I will perform better in interviews for more senior positions, and I will get better offers because of it.

    —-
    On a side note: Google isn’t the only company asking ridiculously hard questions; it’s just the most famous one. In my experience, the most difficult questions from Apple, Kojima, Nintendo, Nokia, nVidia, and Valve have been roughly on-par with an intermediate Google whiteboard question.

    TLDR? Stop complaining about interviews and improve yourself–both your programming ability, and your attitude towards employment -opportunities-.

  • Another Prospective Googler

    Agree with the Prospective Googler. I have my second phone screening with tomorrow, and I’ve been studying quite a lot about Adwords/Adsense, that’s the domain I’ve applied for. Even if I don’t make it to the next round (face to face with 4 interviewers), I would be happy that I applied, my CV got through, and I learned a thing or two from the experience itself. My only worry is my Visa situation… not everyone is as lucky with a passport that allows them to work in any country. And I’m more worried and will be very disappointed about Google rejecting me due to my passport, (not sure if they will agree to sponsorship), than I am about failing the interview. Well, fingers crossed…

  • PhilM

    A fun interview process is where the interviewer and interviewee both get to quiz each other. I know many people who can’t code a simple binary search algorithm (it may not be all that simple, that’s another story) but don’t have any hesitation when it comes to hurling the latest question they read up somewhere. For most people, it’s really difficult to write code on the whiteboard under interview pressure. With these kinds of tough problems, it really comes down to being familiar with them. I bet if this kind of test were to applied to everyone at Google, majority would have to be fired!

    Google might do just as well if they picked competent candidates and made a random selection from it.

  • Jyoti

    Hi , I had interview with Facebook recently and as I didn’t perform well they dropped me. Could you please tell me what is the time frame after which i can reapply like its 6 or 18 or something else.

  • Santiago Gutierrez

    Hi: about the question,
    “Now suppose you are in the middle of Africa, each machine is on an Edge network, and each packet between the machines costs $1.00. Write a solution that minimizes the cost.”
    I don’t understand, it is not possible to send the frequency table in a single package? If not, how much information can you send in a single package?
    There is absolutely no way to solve the problem without every one of the N machines sending at least one package.

    About the RealTimeCounter, if I understood correctly, your solution is logarithmic for every call to getCountInLastX. Those calls can be solved in amortized constant time as follows:
    You store the increments in a linked-list and for each time period you keep a pointer to the leftmost node in that list that was a possible candidate for the leftmost increment in that time period. Each time you get a query, you move your pointer forward until the element you are current standing in is inside that time period. The issue with this approach is that each pointer can at most move N times, where N is the number of calls to the increment function. However, this can be solved by moving the pointers in the increment function, and that way the increment function will be the one with amortized constant time, moving at most 4 * N pointers after N calls.
    About the memory issues: you can save some memory by deleting the node (or leaving it for the garbage collector) each time the getCountInLastDay pointer moves. However, as you correctly noted, the memory usage is quite high, assuming you can only get a single call to increment in every nano-second, the list can be of 24 * 60 * 60 * 10^9 nodes, and if you can get many, then each node should have a counter (number of times called in that nano-second) increasing the size of the node. As some others have commented, it is highly unlikely that the problem can be solved exactly without storing some information about every nano-second that function gets called.

    As for your experience with Google, I just went through the interview process and everything went really well. My recruiter kept me constantly updated, but they did took 3 weeks to give me an answer (which was positive!). I did my interview outside the US, so maybe it depends on the place you do the interview, or maybe you were just really unlucky every time.

  • base3

    Prospective Googler is broadly right. Big tech companies like this constantly have to hire people. Most people who work there have to spend a lot of their time doing interviews and other work related to hiring. They have an attitude that there is an infinite number of candidates, and while they shouldn’t hire anyone useless, it doesn’t matter much if they turn good people away, because there are many more good people coming along.

    A couple of problems with this are as follows. Firstly hiring is done by committee. If the whole team doesn’t agree there is often some kind of rule of thumb, for instance anyone who gets ‘no’s from two or more people is rejected. This means that there isn’t any particular reason that they can give to rejected candidates, and you will usually hear the first one-line answer they could think of, such as “you didn’t seem like you wanted the job”, “you didn’t click with the team”, or “lacks experience in $TECHNOLOGY”.

    Secondly, and more damaging, is the fact that recruiters and interviewers are incentivized to annoy you, waste your time, or forget about you. A prospective candidate, even a promising one, is not worth much to them, so the amount of effort they are prepared to put into not pissing you off is quite low. What this means is that there is a filter effect. People like Prospective Googler end up getting hired. This is someone who puts a value of ZERO on his own time and is therefore ‘happy to be jerked around endlessly’. He is trying out at Google to practise for less picky places, but hopes to get lucky and maybe get a job there. He doesn’t know how to solve interview questions from having learnt mathematics or algorithm design on his own time, for his own interest – he studies to the test and gradually picks up at interviews what he has to study to get jobs.

    On the other hand, someone who has enough self-respect to object to rudeness, who knows they can get a good job elsewhere, who places some value on their own time, who has some sense of their own abilities, or who can tell a good interview question from a dumb one, will stop trying or get rejected. This includes yourself (not to embarass you, but you are one of two or three people I know personally whom I would class as a genius), and another friend of mine, who has an obsessively detailed knowledge of low-level programming and a PhD in graph algorithms (two things you would think Google could use) but couldn’t programm in Python or Javascript, and wasn’t sufficiently fluent in answering questions on basic probability or databases. The problem is for Google that the excellent engineer they turn down is as productive for them as 10 Prospective Googlers (and only costs somewhere between the same and twice as much).

    Joel on Software has written extensively about software hiring and in particular the process by which Microsoft started to go downhill when they went from having exclusively super-smart people to hiring a few Prospective Googlers, who then hired other people of their own calibre, because either they weren’t smart enough to recognize genius or they felt threatened by it. Solution: find one (usually small) company who know that they need great people, recognize them when they see them, and reward them well, and stay there. You only need one.

    • The reason why the Joel on Software “smart and get things done” hiring strategy works now is because there is a glut of people (on a worldwide basis) who are qualified to do computer industry jobs, relative to the supply of jobs. When the situation was reversed, companies were falling all over themselves trying to find qualified people. Also, companies like Google, being very profitable, can afford both not to hire “qualified” people and to hire “unqualified’ people. Unlike small startups, whose survival is highly dependent on the day-to-day productivity of their staffs, large, profitable companies can make a few “mistakes” here and there without materially compromising themselves.

  • Google Recruiter

    Hello!

    First and foremost I want to apologize to anyone that’s had a negative experience with Google– we do pride ourselves in candidate experience, and this is something that I really enjoyed reading, and I will do my best to help address those problems.

    But here are the facts– Google hires THE BEST OF THE BEST engineers. Figuratively speaking around 3 in every 100 people that I speak with end up getting the job. That doesn’t mean you aren’t smart, or that you can’t do the job, that just means that you aren’t capable of doing the job at that moment. Many of our engineers interview 2 or 3 times before they are offered the position. Google wants the best, and despite what you think about the engineers that interview you, trust that they went through the EXACT same thing that you did. So many eyes are on the feedback, so if you did that good, trust me you would have the job. We don’t look at age, sex, religion–all we care about is your brain, and wether you can contribute to Google products/culture.

    At the end of the day, this high bar was implemented by Larry Page, and if you don’t like it–start your own company or go work for Yahoo. There bar is alot easier :).

    • I’m hoping you’re a troll. (Putting in a fake email isn’t a good indication that you’re serious. Neither the grammatical nor the orthographic errors help either.) I’ll respond anyway.

      that just means that you aren’t capable of doing the job at that moment

      This is absolutely false. Not only is “the job” extremely poorly defined in the context of hiring for Google, but I also question your assertion that I am not capable of doing an engineering job that Google might have. I don’t know precisely what Google had in mind, but I have the following to counter your claim: I was given several referrals from several people within Google who are very high-caliber engineers, and I have furthermore been offered a job which makes Google’s bar look like nothing but a stick on the ground. (This happens when the people you work with are cream-of-the-crop physicists, mathematicians, ex-professors from top schools, ex-Bell Labs members, ex-defense lab scientists, and even ex-Googlers.) I was also employed by one of Google’s fiercest competitors (who, as I hear, have a higher bar than Google as well), who also happen to be more successful in their area of competition than Google.

      Google wants the best, and despite what you think about the engineers that interview you, trust that they went through the EXACT same thing that you did.

      As you should probably know, interviews don’t provide enough information all the time. Any slight bias, judgment, etc. can result in a rejection. And in general, it is better to reject a false-negative than to hire a false-positive.

      The issue with the interview process isn’t the fact it’s a high bar. And the issues I discussed didn’t have to do with a high bar either. Google provided an absolutely awful interview experience. And, as I said in the article, and if I am to believe what you purport, you have hired many engineers who aren’t appropriate to work at Google, since many themselves were unable to answer some of the things that I was asked about.

      I was invited back to do a Google interview, by a director of the department you actually work in, who actually corroborated with my findings, and not as much yours. Google wants the best engineers possible, but it’s known that their process rejects many of those.

      I hate to say things like this, but your comment, by far, was the most unproductive I’ve read in this whole thread, and is evidence that you’ve only drunk corporate Kool-Aid, and not actually did any introspection yourself. It also shows that you have an extremely myopic view of what is actually involved in world-class software engineering efforts.

    • Toby

      Yeah, Robert, Google is a MERITOCRACY! You know, like that other co… never mind…

      Also Hi Larry! is that you?

  • notmgsk

    Boom! Roasted.

  • Robert, Thank you so much for sharing your experience(though it didnt turn out to be positive). I too had the similar experience and this makes be believe more in LUCK than being MYSELF :(

  • Hi,

    I’m curious about question #5: “Given a set of Lego bricks of height 1, 2, 3, and 4, each colored differently, write a program to compute the number of ways of constructing a tower of height n≥1.”

    Do we have unlimited supply of bricks? Do we need to count permutation of bricks, for example if we have three bricks of height 1, 1 and 2 and we need to construct heigh 4, should the answer be 1 or 6?

    • There is an unlimited collection of each type of brick, but I am restricting you to picking out $n$ bricks only to make your tower.

      If I specify that $n=3$, then you could possibly choose the following:

      • One 3-brick.
      • One 2-brick atop one 1-brick.
      • One 1-brick atop one 2-brick.
      • Three 1-bricks stacked.

      I hope that helps.

  • Robert,

    Your experiences with Google interviews have been very similar to mine and many others. I think you may have experienced some “interview anti-loops”, and some other problems described in Steve Yegge’s Get that job at Google article. After a number of failed interviews, I started reaching the conclusions that SY did, although I expressed my feelings somewhat differently. For example, I started thinking about the opportunity costs of interviewing at Google. For example, if I am studying something that Google claims is important, what (of the numerous other things that are “fair game” for a tech interview) am I not studying (that might be relevant to some other company)?

    If I have time, I’ll write more.

  • [Note: In response to this comment.]

    Google Recruiter,

    Perhaps you are correct that a person who does not pass a Google interview cannot do the job at the moment. (I disagree, but that’s just my opinion.) However, Google (and some other tech companies) have complained to the US Congress that they cannot find qualified candidates in the US, blaming poor education standards. By your own words, this is not true. Google has plenty of qualified candidates that they turn away because (in their opinion) they are not able to do the job at the moment, not because they are not qualified to work at Google. IMO, Google (and other tech companies) should be honest with the US Congress about their hiring practices.

  • [Note: In response to this comment.]

    Prospective Googler,

    I am not sure that Google’s interview process aids in the interview processes of other companies as much as you think. In my experience, other companies (for example Cisco, Juniper, F5) don’t have easier (less competitive) hiring criteria than Google does. Not only do they have harder criteria (in some cases) — they have different criteria — criteria that someone who is focusing on the things Google claims to be important would not be thinking of (and/or have little or no experience with), and thus would struggle with on an interview.

    There are numerous “axes of difficulty” for any given subject area, and a professional in the computer industry might be asked to address multiple subject areas in the course of employment with a given company. (In other words, a computer industry professional might need to wear many hats.) Thus, any interview can be made arbitrarily difficult (from the perspective of someone who doesn’t normally do that type of work). It isn’t even the case that the person could not do the work (given sufficient time and resources).

    I also agree with others that it is not necessarily in someone’s best interest to pursue employment at Google if he or she values his or her time more than Google does. Such a person is right to recognize that he or she may be paying a high opportunity cost for trying to get hired by Google, potentially overlooking other, more promising and satisfying opportunities.

Leave a Reply

  

  

  

You can use these HTML tags

<a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>

Before you post, please prove you are sentient.

What is 7 * 8?