1. Go to indeed.com
2. Type in 'software engineer' or 'data scientist' or something like that.
3. Don't put in a city.
4. Put the money slider all the way to the top.
5. Open a few pages of job postings in tabs.
6. Write down every word you don't know.
7. Repeat the process by searching for each one of those words you don't know and then write down additional words you don't know.
Now you have a list of what technologies are valuable in the zeitgeist and your mission is to determine why each technology exists and what it's use case is. You'll then be armed with a larger and more modern toolbox full of tools to reach for when the time comes to solve that kind of problem.
Rinse, repeat every few years.
Hope that helps someone. :)
I'm going to get a lot of pushback for saying this, but there are basically three roles in any company: (a) people who do the work, (b) people who make sure the work gets done, and (c) people who decide what work to do.
If you follow the strategy outlined above, you will never rise beyond a pure implementer of someone else's vision.
Empirically, understanding more about the business domain and industry seem to be important if you want to do (b) or (c). If anyone has more tips, I'd love to hear them.
EDIT: When I say "above", I'm talking about in the comment two levels up, not the article.
If you understand why a technology exists you are gaining an understanding of problems, and after repeating a few times over a decade you may see patterns in problems that are being solved.
It's easy to mock "AbstractSingletonProxyFactoryBean" but whoever created it was not being wholly onanistic, and if you can't understand why it was created, you are going to be in trouble if you ever create your own framework.
I'm not sure it's something that can be filtered for, but I don't want to work in an org where technical decisions are made by those who's hands aren't dirty.
ghotli did address that, obliquely.
Another good term is to do "Term VS ______" in google to learn about competing technology use cases as well
At the end of the day some of these terms are possibly all buzzwords but its nice to see what actual companies are using, what that business does, and why they might be using it. Sometimes you get some really nice insights when you dig down deeper (look at their forum posts, etc). This is especially true for things like ecommerce carts (run wappylzer → inspect what the site is running on), sometimes you can actually physically see the decisions they made at a company publically.
I dont see a slider on indeed. What are you talking about?
How helpful would this be for someone self taught looking for a job?
We had a programmer that tried from the start to impress us. They were constantly suggesting new tools, or changes to the system, or trying to abstract some code.
What they weren't doing was what we asked them to do. They'd put a token effort into that, do it wrong, and then call it done.
On the other hand, all my best newbie programmers came in, buried themselves in their tickets until they understood them, fixed them, and went on to the next ticket. There was very little attempt to change the system in their first year.
I'm much happier with people who focus on doing their job instead of focusing on trying to impress people.
It sounds like you're looking for ticket monkeys; the article is about how to become more than that for the people that aspire to that.
The fact that you call your new hires "newbies" and don't expect them to make suggestions for a year is a huge red flag for me. Either you didn't understand that the article is targeted towards experienced professionals switching jobs (first sentence), or you think that a professional will take an entire year to understand your org and be more productive than work on tickets.
Most devs that I know worth their salt are comfortable switching jobs every 2 years or so (whether they choose to or not). The contrast between that and not even being expected to think for a year is massive.
People who have an established pattern of changing jobs every 2 years won’t even get an interview in my org, and they definitely need at least a year before they understand the problem space well enough for their offers of major architecture changes to be welcome.
The idea is that coming in and working on the problems you’re assigned is good because you can more deeply understand the problem space AND make things better.
I expect this, better and faster and with more humility and wisdom, from senior engineers. That doesn’t make anyone a ticket monkey in my book, it makes them effective at their very highly paid job.
As an aside, I highly recommend the article’s strategy for appearing (and hopefully actually being) wise and humble, as long as you’re getting your assigned, bare minimum work done.
Anyway, it sounds like maybe we mutually wouldn’t want to work with one another, which is why it seems like we live in different worlds to me.
I think there's a role for humility on both sides. In my current role, I was an experienced hire. After a month on the job my manager and his manager pulled me aside and said "What are we doing wrong?"
The interesting thing was that when I told them that I thought their module system was seemed backwards, the response was "Yeah, we know. It's a quirk of history that it ended up that way, and we've got a plan to fix it. Anything else?"
They very much valued a fresh set of eyes to ensure that they weren't missing something they had become house-blind to. At the same time, as a set of fresh eyes your attitude should be one of questioning, "Why are we doing it that way?" rather than "We're doing it wrong" or "This way is better".
Here's the trick: Every weird architecture exists for a reason, good or bad. If it looks wrong to a newbie, maybe the newbie misunderstands it, or maybe the business can't afford to build something better (and it's good enough as is), or maybe it really is wrong but the people who built it like it, so what good will come of you you trying to change it? Your newbie ideas only help if the veterans want new ideas and also your newbie ideas are better than their veteran ideas. That's possible but rare.
The key is understanding that your teammates are probably pretty smart, you can learn a lot from them. You’re probably really smart, too, better to show your new team this with actions and quiet side conversations than showy pushes for unwelcome change, at least for the first year.
Fresh eyes are incredibly valuable and you only get that once from each person before they become just as jaded as the rest of the team ;)
The OP is Silicon Valley royalty. This matters. His site is pretty humble, but this guy was like, employee #10 at facebook and is probably worth high 8/low 9 figures. He is respected in a way most people aren't.
Boz can come in and start making these changes. Most people can't. We need to talk about this more. We labor under this bizarre illusion of non-hierarchical workplaces in Silicon Valley, when the reality is and always has been, some people have more influence than others.
I find it helpful to keep in mind the circumstances about the advice-giver as much as the advice itself. I'm not saying there aren't good nuggets of advice to glean. But who you are and your track record really matter in Silicon Valley and we should acknowledge that. It's not as much of a pure idea meritocracy as people think/pretend.
After a while longer, I changed that to "regardless of the org structure, the org chart doesn't fully capture who has influence and who doesn't."
refers to the 1972 essay The Tyranny of Structurelessness by Jo Freeman. http://www.jofreeman.com/joreen/tyranny.htm
Nothing new under the sun.
No offense intended, because I don't know your situation, but as someone who has worked in several industries, every time I've heard that kind of phrase it's boiled down to some combination of unnecessary complexity (of architecture and/or process) and undocumented tribal knowledge.
I can't imagine any problem space that would take a senior developer a full year to become competent.
In fact suggesting major changes to architecture is a strong signal of an immature developer. There are times when major changes in architecture are warranted, but they are suggested far more often than that. The implications of the suggestions usually mean rewriting lots of code just to stand still.
TBH, I'd only suggest changes when they are really required (i.e scalability issues, maintenance issues, etc) but that has nothing to do with how long I've been working in a project. Requiring a year of knowledge about the domain is nonsense to me.
I am somewhat arbitrarily latching onto your statement as a place to respond. But my thoughts are swirling around many other posts in this whole thread... I think "problem space" conflates too many different aspects of real world work which can all require significant time to comprehend as a new member of a team.
Any non-trivial project must include hysteresis in planning and management, meaning that an architecture encodes a number of economic decisions and strategic positions. Hardly anybody would look at a long-lived project and declare that they would build it the same way if starting from a blank slate that day, but this is irrelevant when considering overall engineering costs and risks. Things must be far worse than "not ideal" before it makes sense to invest in rebuilding existing functionality rather than maintaining it.
Secondly, the actual "problem space" is what gets assigned to subject matter experts in very large organizations but must also be understood by those making engineering decisions. I don't think that there is such thing as a "senior developer" who can waltz in and start declaring how to solve problems without learning this subject matter, and it can certainly take years to acquire such expertise. You can't just know how to build things to spec, but must have an appreciation for which things to build, and what business purposes are being served. Often, a worthwhile rearchitecture is not simply refactoring the code that performs the same thing, but refactoring the entire solution to address subject matter problems in an entirely different way. Sometimes, the subject matter is highly technical (like physical problems, or logistical optimization, or machine vision) and sometimes it has much larger social components (knowing the customer/user and their requirements or limitations).
Finally, there is a third space of expertise which gets to the heart of some complex projects. A deep understanding of how an engineering organization functions and of its members can be another realm of subject matter expertise. You can't appreciate the economic and application decisions encoded in the architecture if you aren't aware of the strengths and weaknesses of the team. Sometimes, a senior person with deep technical knowledge can be faced with the worst truth of all: a better technical approach that you are well acquainted with is simply inappropriate for a project that does not have the staff nor the will to build and maintain it. Decisions are hardly ever so modular and independent that we can satisfy all participants without compromise.
Unless by "Senior developer" you mean someone who already has experience in the problem space, of course. If all you do is ecommerce, then, sure, you're already competent at ecommerce (at least hypothetically you could be) because you've already spent more than a year at it.
I agree. I apologise because I don't have the time to give you a proper response. Most of the things you are talking about that are things that transcend specific problem domains and can be learned over the course of many years in a career. The point I'm driving at is this: a "senior developer" should have already learned most of this and be and to apply it quickly to new environments. Very few things, and very few situations are truly unique. The same patterns surface in most of these teams/products/problems.
I don't expect a senior developer to necessarily be able to become a SME within a year (though for many domains that is well within the range of possibly). But I do expect a senior developer to be able to able to successfully design software systems alongside a SME within a year.
I am not so arrogant to claim to have seen every possible situation, but I have been around a fair amount and every time I've seen companies with "unique problems" that "take years to understand," it's been the fault of unnecessary complexity, regular miscommunication, or too narrow of a view. One company, for example, had spent so long staring at their own version of the problem that they were unaware of how similar it was to other problems that had already been solved.
One of the main skills of a good developer is the ability to decompose problems and create abstractions. It's one of the main benefits of some of the algorithmic courses you'd take in a CS degree: a survey of what is computable and the broad lay of the land that computational problems fall into. Of course, it can take several years to learn how to apply that knowledge, as well as all of the not-technical skills you mention above. But based on my experience I would guess that the majority of companies that think they need years to train people up in their domain either don't really have an understanding of software or don't actually have a firm understanding of what they are doing. Things are hard to teach because they're fundamentally not well understood by the instructors, not because they are fundamentally hard to understand or learn.
I'm curious what domain you're in? I get the sense that different real-world topics account for much of the difference between developer 'worlds'.
I remember talking to a few rocketry companies in college (not SpaceX), and they were overt about wanting someone who would start out doing rote work and already had substantial expertise in their C package of choice. I certainly cant blame them; their risk profile is fundamentally different than almost any other software domain. (The exceptions, like military and aviation use, also tend to be pretty hard-nosed.)
"Not doing assigned work" is obviously a terrible trait basically anywhere, but the other divide here is really interesting to me. There are a lot of very successful companies which hire 2-year-turnover staff and assume they'll get the same, and then there are companies like yours with 'dark matter developers' who would never cross paths with that.
2 years? Most of the companies and projects I joined were long gone and dead 2 years down the road. Different industries indeed.
But, I have not worked in a startup environment for almost 20 years so maybe in the right environment it is totally normal to expect people to jump around that often. I would advise being careful about keeping that up if you ever plan to move to a more stable part of the world because it is a stain on your resume.
Why would it take you 2 years to understand it about someone? In my experience, real figure is closer to something about 2 weeks.
I haven't yet run across a valuable team member with a track record of short gigs, but I've run across several people who, in retrospect, clearly were just going from company to company in the area until they were too well known and then fled to another metro.
I'm so thankful that I'm living in one of the socialist european contries right now. Not being able to fire a bad contributor from my team would just make my blood boil.
How long did it take to learn those skills? Do you use a tool to understand the code? What is your advice for coming up to speed on a domain you are unfamiliar with?
IME, hubris usually correlates with architectural problems and higher than normal technical debt.
I can't see any good reason to analyze ideas about architectural overhauls on anything other than their technical merits. If there's a reason relating to the problem space for rejecting one particular idea that's fine, but unless your architecture is completely fucked that should be very rare.
It's perfectly normal to tear out the badly written guts of a software system and build up a better version, and a deep understanding of requirements should not really be required to do that in most cases.
Precipitating new conversations with strong implication there’s a better way is less welcome. You can only have “we need to rewrite this” conversations about your core area so often per year before you get a jaded burned out team. New people should wait for those conversations at the team’s natural pace.
This phrase creeps me out. It reads like you're putting a thin veneer of "corporate happyface" over a heart of "STFU and do as you're told, children".
Maybe that wasn't the intention, but still... that's how it sounds.
>Precipitating new conversations with strong implication there’s a better way is less welcome.
Provided you are thick skinned enough not to take offense I don't see the problem.
I've had conversations like this with juniors where they want to rewrite everything and I usually drill in to what they're saying using a kind of socratic questioning method and get them to explain on a deeper level what they think the benefits and costs of the approach they're describing is.
This process is both instructive (juniors are typically pretty bad at cost/benefit analyses, and need to learn) and it makes them feel like they're being listened to. Usually it ends up with an agreement about how to proceed - which is often "good, but not high priority idea but let's put it on the back burner" and is sometimes "bad idea, actually, but that's ok".
IME you get jaded and burned out people much quicker by instinctively rejecting suggestions and telling them to knuckle under, do as they're told and not speak out of turn until they've "earned" the right to do so. That's also a fantastic way of keeping genuinely good ideas and salient observations under wraps.
While I understand where you are coming from, you are missing a great opportunity, i.e., getting an outsider look on what you are building.
I think sometimes folks just aren't a match for a team.
That's not the problem.
The problem is that some newbies want all of the code to be their design pattern of choice; or just want to refactor things until they understand it. Some will just refuse to follow established design patterns and do things like bypass our dependency injector.
For me, it's a red flag whenever someone comes on a team and immediately wants to refactor to use their favorite design patterns, frameworks or style. It's not that their preferred design patterns are better or worse than what we're using; it's that you just don't refactor code on a say-so.
A smaller project that's in a constant state of flux? Of course suggest giant overarching changes when they appear to make sense. What's proper depends heavily on the context of the group and project.
I've seen a lot of people come in (category A) who can spout best practices that we're not following, but can't ever wrap their heads around the way the system works, the amount of effort that implementing an idea will take, and the amount of payoff it will offer. They just cargo cult best practices. With those people, I want to say "please just crank out tickets until you understand more".
However, there have also been a small handful of people (category B) who come in, and quickly find ways to make beneficial changes that are achievable and worthwhile. Those people are incredibly valuable.
Concrete advice: if you take a year for any new hire to understand things enough to make changes, you need to work on the understandability of your system, your onboarding, or stop hiring exclusively from category A.
That seems like a perfect description of doing a good job at resolving tickets to me. Because if the change was beneficial, it was presumably not just navel gazing architecture astronauting, it was solving an existing problem, right?
The red flag in the ramp up curve is really for Senior engineers. If I didn't have a solid understanding and demonstrated ownership of my problem domain within six months along with meaningful projects getting pushed through - my manager would likely be starting an awkward conversation with me.
Part of problem finding is also taking vague inputs "that subsystem is kinda wonky" and transforming it into "that system has these specific problems, which can be fixed with this approach, which will take roughly this long, and help out this much".
The existing group may not have made tickets for something because they think "it'll take six months" or "we'll have to change x,y and z before that idea is gonna help us", because they don't have the time to analyze a known pain point for how painful it is, or even because they haven't thought of the improvement. Then someone realizes that those assumptions are wrong, and finds a big improvement.
On the other hand, I feel like you're coming at this from the perspective that your existing team is omniscient, or at least always knows better than someone new. We used to have that dynamic, and I think it's better that we're now more open to new ideas (onboarding is still way slower than I'd like, but it's improved).
Brand new not-desired-by-team features/changes often end up owned and maintained by the existing team for a long time, often long after you’re gone. You, as a new person, probably aren’t shouldering much maintenance burden yet, bad to be perceived as adding more rather than reducing load.
Much better to fix a generally acknowledged problem, reducing maintenance burden for the existing team.
But assuming my high performing senior matches your definition of senior, my experience doesn’t really match your approach with “likely better to bring on a few junior engineers to tackle those rather than Seniors”. The people I think of as high performing seniors will do wonders at making a collection of desired bug fixes and required improvements get done and leave the system with, net, fewer bugs. So it’s never better in my book to assign such problems to juniors.
Some juniors do this, at a lower fix rate. Others introduce as many bugs as they fix. Those either get better fast, or get managed out. So in my world, juniors are a resource (“the future!”) we carefully husband, but try not to have many of them on any given team, because the variance in outcome is so much higher.
There is something called Chesterton fence principle: https://en.wikipedia.org/wiki/Wikipedia:Chesterton%27s_fence - before proposing to change something, give it an earnest try to figure out why it was like this before, and what changed. Sometimes there's no good reason, or the reason once existing is long gone, and a fresh eye is useful to shake out those cases. In other cases, there are complex and unobvious reasons that cost a significant effort to figure out, and may be not apparent to the fresh eye. So it's better to keep an open and humble mind and at least at first, approach new system with the attitude "please help me learn why it's like this" instead of "this looks wrong, let's throw it away and re-do it from scratch". I'm not sure about a year, but at least a month or two would probably be appropriate. And my experience showed dealing with bugs can actually be very instructive about how things work and why they work this way and not the other.
Anyway, the article is more about humbly learning how the team works, not about rewriting their codebase just yet, i.e. the opposite of your point about "ticket monkeys."
Often new leaders & managers start in an established team and want to change something to "make their mark" or have an impact as soon as possible, often with disastrous results (because they don't yet have the context to make informed decisions).
The advice is to spend time with your team to learn the ropes, figure out the internal politics, hear the common pain points and _then_ start addressing things, hopefully with some quick wins (like canceling a wasteful meeting or appropriating a larger conference room) that due to organizational inertia, went unaddressed.
When I come to a new team, I always try to find out a lot of things during the coffee breaks. But the approach from the article is more structured.
So, I guess I will try a mix of the two approaches next time ;)
Does it mean they start taking on projects that don't align with their role? Probably not. What it does do is enable them to get a fresh perspective on the org, team and work and perhaps contribute ideas in group settings/meetings/social situations that others may not have considered, by virtue of not having executed the algorithm in the article.
If nothing else it gives one a structured way to gain valuable information about the org and the work, regardless of where you sit in the 'food chain'. It's also a great way to build a network.
Often companies allow for 'stretch' time where ICs can take on side projects. Running this algorithm could be a great way to surface ideas for those kinds of projects.
This seems like excellent advice for individual contributors, of whatever seniority, if you can already kick ass at the work you’re assigned, maybe after the first month or two. Provided you have the diplomatic skills to broach process change ideas in a way that doesn’t leave you looking like an entitled asshole, of course. But then, maybe that’s what you meant by “leader”!
He says ask to meet people to understand how everything works. It's not about impressing them, even if it shows proper respect as a side effect (and showing respect by listening is quite the opposing of suggesting new things nilly willy).
I think the "listening tour" is a pretty good idea even if you aren't a manager. But what to _do_ with it, needs somewhat different advice.
I also suspect the programmer in the comment I'm replying to did _not_ in fact do the "listening tour" that is the main recommendation of the original article. It's not advocating for suggesting changes based on your personal opinion, but only after learning what the team thinks and based on what they think. So the programmer in the comment I'm replying to didn't follow the advice at all.
I agree though that this should not be advice for novice programmers, as in this moment of the career you are not sure of the most common pitfalls a team/project gets into and should be mostly concerned about learning the technical knowledge. Trying to do anything else will be a distraction from your current goals.
Very helpful advice for consultants or team members who really care about the project and your career.
But again, as said by a sibling comment, you should always pay attention to disfunctional environments and avoid getting too much attention from sociopathic managers/technical leads. Get some advice from the peers at the same hierarchical level first to know if things are handled smoothly, before iterating.
To quote the seven habits of effective people:
"Seek first to understand, then to be understood"
It gets more awkward when you're brought in by one person, but quickly realize that the people you're working with don't want you to do what you were brought in to do. Or when people tangential to the project see it as a threat to the status quo and actively try to prevent you from doing what you're trying to do.
Also consider that the people there aren't dummies but know what they are doing. One of the biggest career improvements I have made is to assume people are competent until I get clear evidence of the opposite. This makes relationships much more pleasant.
[I've spent a lot of time this morning trying to articulate further, and I'm too distracted by the work I'm trying to do. Sorry.]
> We had a programmer that tried from the start to impress us. They were constantly suggesting new tools, or changes to the system, or trying to abstract some code.
If you had people like that, and you weren't able to utilize their talent, then your workplace sucks.
The right way to go when someone says "We should do $X!" and you don't believe it is to say "Prove it!"
Improvements aren't free. They cost, usually more than just the opportunity cost of the implementer's time. There are lots of ideas for improvement that will cost more than they deliver. If I have someone consistently suggesting them, no, I have no place for utilizing their "talent", and no, it's not because my workplace sucks.
I'm not sure I would call that "talent", and based on that performance, I certainly wouldn't want their "improvements" on our systems.
I assumed it would be around 5-10 meetings over a few weeks. Half of which can probably be done on lunch breaks. So it shouldn't take too much time away from real work. Obviously you should be working in the code base daily, but in the beginning working 8 hours a day is probably less efficient than working 7.5 hours and spending 30 minutes actually asking someone to explain parts of the code base to you.
How many of these meetings do you think the author is suggesting?? Even one day of that is 16 meetings, roughly the number of people I worked with on a regular basis at Microsoft.
Clearly the author is suggesting to mix them with regular work. One hour of effective meetings per day, plus seven hours in the code, is going to be vastly more effective than just wallowing through code for the entire day.
Can you explain why, please?
So, that said: The whole point of using "they" is when you don't know the gender of a person and don't want to presume by saying "he" or "she" or muddying up the text by saying "he or she". When you know the gender of a person, using the correct pronoun is better--it's both succinct and corresponds more closely with reality.
It's a touchy subject [I mean, some idiot flagged my comment--come on!] but people tend to over-correct in grammar quite a bit, and over-correcting with "they" happens like this.
Perhaps the parent was trying to conceal the identity of the person in question and gender would be too much of a giveaway.
- disorganized workplaces run by a paranoid manager (all too common): The tactic would probably be conceived as taking too much own initiative, and 'stealing' 30 minutes from an arbitrary number of employees would not go down well (even if it was in your free time). You could try and get managerial sign-off, but don't count on it. If you really need that job in the first place (it's going to be a rough ride) better do over a beer or similar. It is why 'after work' was invented in the first place after all.
- as a very junior or entry-level employee it would seem like overkill in most teams, and probably not work to your advantage. In that case, and if you're ambitious and want to move quickly, try to get the same information but in a less overt way.
This is knowledge work we're doing here; we're not working the assembly line.
Lacking in enthusiasm, perhaps. There is something to be said for people who venture into every new setting with an optimistic mindset, and not caring if they should tiptoe round, so agree inasmuch.
On the other hand (based on 40 years+ of professional experience), workplaces are in reality on a spectrum regarding these things (not binary good or bad), and peoples seniority as well as their need to take any job in the lower end are on a spectrum as well (some need to take what is provided because of location or other factors). In certain intersections of these factors I'd still say be careful to follow the advice in the linked article very literally.
In the appropriate cases I'd say it was excellent advice though, perhaps that wasn't clear enough.
"made dull, apathetic, or cynical by experience or by having or seeing too much of something" 
I would say that someone who feels that it's commonplace for managers to refuse to allow new employees to schedule 30 minutes with other members of their team while on-boarding would fit the definition of being overly cynical.
That said, thanks for a better definition of 'jaded' even if not applicable! :-)
You don't have to start with the senior project manager. Try to find someone who's equally entry-level and been there less than year and talk to them. They'll no doubt be happy to talk and teach you the important things that you actually need to know in your position.
Unless they are jaded from being underpaid or stuck at a position they dislike, which is a very common theme in Eastern Europe and middle East.
Which would definitely be something important worth knowing.
As such it shouldn't matter if they spend their 25 minutes going through the architecture of the build system or ranting about their manager, both will teach you something useful.
> things you can easily help with, like “we waste a bunch of time in meetings every week” or “we need a dedicated conference room.”
But agreed, a junior could do the same thing in a less overt way.
I think the advice in the article was excellent - to the point that your summary quote does it some injustice. But my comment regarded some edge cases, among which the case when a new leader would be compelled to take a job even if workplace was in some disarray. Obviously, if one can pick and choose then it doesn't apply.
You basically can't win in a place like this. It's better to keep your head down and leave as soon as you can and try to see the warning signs before taking the job in future.
It’s somewhat applicable to individual contributors, but it’s intended more for managers, which I didn’t realize until halfway through it. Might just add some clarity for folks opening it up without any context.
It’s not like only managers can propose slight shifts (desired by the existing team, explicitly in this construction) in process. Unless you’ve got a real jerk of a manager or aren’t doing your base line job well yet, such suggestions, if broached carefully, ought to be welcome.
"...the natural instinct to push for early impact leads many incoming leaders into challenging relationships..."
I have applied the same method to several companies, and that didn’t lead to a lot of goodwill in highly dysfunctional places. The crux of the issue is that in many places, people can’t offer a consistent and exhaustive view of their work in 25 minutes. Being about to do that well enough that no other meeting is necessary it’s actually quite typical of Facebook where the pressure for people’s time and meeting rooms is so high that most meetings are 30-minute long; most people are smart and curious enough to be able to structure their entire role and its context, and fit that in a cogent 25 minutes, including questions. Elsewhere, you might get into trouble for trying to make sense of a lot of frustration, under-optimal decisions and misunderstandings.
Most places aren't at their level of alignment or clarity; it's a huge jumble of poorly-prioritized tasks and dysfunction.
- a constance focus on finding solutions: if you don’t know something, that’s not your problem, you managers pivots that into why it wasn’t taught in Bootcamp, why it wasn’t checked; you are never stuck or blamed: it’s always about establishing a long list of things to do, many personal improvements, and having the most important on top; “How can we fix this?” is the default response and it works really well;
- no hesitation to replace managers: I did work with people who were not… great at sharing their vision, and their responsibilities changed, often and fast; there is a quarterly detailed review leveraging a very detailed poll of all employees — outcomes are shared, decisions are public and debated at every level; authority is never something you own, and nowhere else have I seen so many senior people go back to the trenches because they though that would be best; little surprise though: their ability to take and act on criticism meant they generally get promoted very fast again;
- no hesitation in promoting unconventional people for management role and allowing them to be themselves, because that role is not about being the best, but the most able to give a team a direction. No where more than there have I reacted “Your manager did WHAT?! No, that’s awesome, and brutally honest but… Wow.” Sharing graphic details of pregnancy (to ask for specific team support around length of meetings), alternative hobby (like, really — to explain an issue with one use-case). No shame, just constructive direction.
'Onboarding jumpstart' seems like a better title, maybe 'newhire jumpstart' as an alternate.
This is really good advice that can probably actually be generalized, though it doesn't really tell you how to do the actual hard things (like how to take care of that meeting stuff).
(I'll make a different post about my own meetings rant)
“What are you working on? What’s next? What do we need most?" 1-on-1, less than 30 minutes, we're a pretty loosely structured org so it’s all self-initiated. Works well, I’m more comfortable with my colleagues and they’re more comfortable with me, we know roughly what each other are working on, and bandwidth is so much higher in person than on video or text chat.
This advice applies to managers hiring new positions as well, make your new hires do this!
The position in my career where I had the most success started with my manager on my first day pretty much setting this exact exercise as my objective for the first week. He gave me a list of 3 people to talk to and told me to find out who the other people were for myself.
1) Look at the bug backlog and pick one that's obvious and reproducible
2) Set up the environment(s) and start to debug (It's surprising how painful this step can be in some organizations, but for any team it will showcase a number of pain points for the developers and testers.)
3) Skim the related code history and make a list of people to talk to from the commits.
4) Informal meetings with those people to ask questions about the product, codebase, and what they see as major problems or bottlenecks.
Step three from the article ("ask who else you should talk to") is something I hadn't thought of before:
The third question will give you a valuable map of influence in the organization. The more often names show up and the context in which they show up tends to provide a very different map of the organization than the one in the org chart.
In large organizations there are often a number of lynchpin-type people (often in non-senior roles) scattered across teams that everyone respects and goes to for information and advice. Finding these people early saves a lot of time and frustration.
Soon you will see what the main struggles are in the company, who opinion leader is, and what the product development dynamic is. Only then, when you figured out the playing field and all mines you may start talking more if you really have something to say.
This is a perfectly sensible guide for engineers in the second half of their career.
When you are young and fresh, it is the company's job to make use of you and make you productive. Effectively, the first thing they should do is intro you, give you a few learning projects, and help course correct to get you productive. Managers invest time in this so that the manager effectiveness amplification occurs.
When you get old, senior and soulless, once you start getting hired as a lead, this algorithm is basically exactly what you should be doing in your first 30 days. At that point you're almost always being hired to fix something that's broken and it's your job to make yourself productive for the company instead of the other way around and then help make other people productive (or, more often, make other people less unproductive). Putting aside the very rare exception where you are your own brand name and can get vanity projects and total control, the only real exceptions are when you start a fresh company or project and have total control, but those opportunities are comparatively rare. Most senior engineers hired into a new org who are in a leadership position will find these steps quite sensible.
The big issue I tend to have with normal corporate meetings is that everyone seems to be a complete cargo cult amateur at it; even when they try.
I think I'd much prefer a "remote first" style of meeting, where everything is designed as an asynchronous, clear deadlines for contribution, process. The actual meetings should be broken up in to focus-groups tackling a specific task, such as brain-storming the definition of a problem, or that problem's solution.
Another thing is that much of the organizational memory these days is available electronically. When I join new team, I go through recent documents, slides, meeting notes, emails in internal discussions etc in first two days that is available to everyone in the team. I also learn building source code, looking at architecture/design docs, their evolution over time, release plans etc. After doing all these for first few days, it makes sense to ask specific questions as opposed to let me Google it for you questions and you would look prepared and worth spending time to talk details beyond giving elementary pointers.
Thank you for it
For everything people related for me the very simple approach worked best:
- find a topic where you can see the other person getting a profit for their problems/career as well
- start discussing that topic with them
- if you hit it off, stay in contact
- if you don't hit it off, try to reduce contact as much as possible
And then work hard and try not to be a dick, but be a dick to people who want to exploit you. If someone worthy gets a bad impression because you self-defence he will come around when he sees you in action more.
What the interviewer does with that information is another story ( likely multiple other stories ).
This hits me hard. I always go into a company and ask to see its org chart so I can get a feel for where I'm at in the company. I have been frustrated before because some companies don't have org charts or they are inaccurate. I will be using this trick in the future.
This provides an efficient way to learn the team, garner respect, and create a platform to do bigger things down the line.
I have seen far more accomplishment using this formula than the blunderbuss "we have to make changes now" approach.