[Continuing because of HN's length restrictions]

> In the code base that you live in, you quickly develop an
> understanding of how the components fit together. Use this
> knowledge: instead of only fixing a bug you're assigned, consider
> how you can prevent that class of bug from ever happening
> again. Instead of implementing a new feature, consider how you can
> create a common abstraction between the new and old ones and share
> 80% of the code. This might take more effort now but gives vastly
> greater results in the long run.

This is a very beneficial thing to do, but it led to ugly code
reviews. I was given a task, and solved it to satisfaction (code was
written cleanly, tests passed, etc.) but was told, in review, that the
code was not satisfactory, because it did not clean up code completely
unrelated to the task -- even if such clean up actually didn't solve
any old or new problems.

I was severely penalized for this.

> At a higher level, take ownership over the entire company. Don't let
> your coworkers be less than the best that they can be. Understand
> the trade-offs being made and the factors that led to them;
> understand temporary solutions and the priorities that necessitate
> them, but don't accept a decision that you feel is wrong without
> raising the issue and getting a better understanding. This is your
> company (your garden) and if you let people pull in the wrong
> direction the entire plan will fall into disarray. Make sure that
> you encourage changes and that you're confident that the changes
> happening are the right ones.

This sounds entirely ideal, but when someone new goes up against
someone who has been in the company for a while, the new guy is the
one who is looked down upon and usually disagreed with, with the
reason that the guy with tenure surely knows what he is talking about.

The part left unsaid is that there is no process for appeal. If you
disagree with another developer, and your manager ultimately disagrees
with you, tough luck.

I did not see democracy and debate. I saw tenure and social capital
deciding issues by default.

> It's easy to fall into the mindset that you don't know everything,
> everyone around you is smarter and more experienced, and that if you
> say something incorrect you'll be judged by your peers. This isn't the
> case. When you have an idea, share it with your team, even if you
> aren't confident it's the right idea. Wrong ideas are often stepping
> stones to right ideas, both because they help define the real
> boundaries of the problem that you're facing and because you can
> iterate on a wrong idea to reach a right one.

Saying incorrect things, in my experience, actually does have
repercussions. During "bootcamp" at Facebook, you'll go through
essentially a second set of interviews with managers and team
members. If you ask the wrong things, or make seemingly incorrect
statements, you will be judged, and as a result, they will not want
you on their team.

Aside from the questions you ask and the interest you display, the
number of questions you ask also is a form of penalty. I was
informally rejected from a team because I was told I asked too many
questions. Basically, since I asked too many questions, I allegedly
did not have the competence to solve problems that team faced on my
own. Even though it was the team I dreamed of being on, and the one I
could make the most impact on, I was told by my manager that my
reputation was irreparably befouled. Maybe if I tried again in a year.

As another anecdote, I was judged negatively for sharing my ideas
without confidence (I'm the new guy, I don't want to be
presumptuous!), and being indirect with criticism. Instead of telling
another team member that he was wrong, I shared an experiment and
results to demonstrate so, in order to minimize argumentation.

Even though I ended up being right about my assessments of the problem
at hand, I was actually told that I should have been more assertive
because of this, and my overall performance was deemed poor.

> It isn't immediately obvious how important it is to meet and
> maintain relationships with people at the company who are outside of
> your team. Find a random person with whom you haven't worked in
> months and have a quick chat with them. It can provide a fresh
> insight into problems you're facing and may even give a solution
> that another team already has that you can use. FYI groups do a good
> job of giving you a broad overview of the company, but talking to a
> ground-level engineer from a different part of the code can yield
> new ideas, new solutions, and new opportunities to combine forces.

True enough. Though, "joining forces" usually means "do something for
the company on your own time, and if the idea is good enough during a
hackathon -- also on your own time -- then it might lead to a new
opportunity". You can shoot the shit with other developers, but
there's no 20% time to take anything to the next level.

> I'm only just starting to learn some of these lessons. I hope this
> note helps to inspire you to step up, take ownership, and lead your
> team in the right direction. Enjoy your years at Facebook; I know I
> have.

Good.

Overall, I did not enjoy my time at Facebook, and I was reminded of
the value in having a good, experienced manager, and the futility of
trying to retain professional dignity in the face of an incompetent
one. It was something that could have been repaired, but there was no
avenue to do so.

My tale also underlines the way at-will employment can be exploited as
"endless probation". Food for thought for anyone seriously trying to
build a tech career.

* Actually, I am glad to say that I am now happily employed.