33 ms·
Software Engineering at Google (2017)
- MeteorMarc 8y ago"Individuals and teams at Google are required to explicitly document their goals and to assess their progress towards these goals" This seems attractive for other large organizations. Any positive or negative experiences from readers?
- jamisteven 8y agoMost large companies operate this way. Its great as long as the powers that be actually action these assessments and validate confirm the assessment with other members of the team.
- Izmaki 8y agoWe do this at a smaller scale (~1500 employees) with success. It enables everyone to work towards a goal and to discuss with their superior any issues that get in the way, as well as every success story along the way. Both are very important parts of the journey.
- aquadrop 8y agoWhat goals/steps are there? Is it anything more than something like Goal: get promoted/get higher salary Steps to the goal: did my job well ?
- Izmaki 8y ago"Did my job well" might be one, but it's hard to measure... otherwise see above :D
- auiya 8y agoYou essentially set arbitrary metrics for yourself (create X widgets, approve Y new hires). And then you do those things. And then you pat yourself on the back for doing those things. And then you get passed over for promotion anyway because "maybe next time". It's a way for companies to not promote you based on nits they picked with your own write-ups.
- taivokasper 8y agoCould you bring a any examples of individual goals? How are they worded for devs and how different they are from the product goals?
- Izmaki 8y agoIt's not easy to list goals from the top of my head as it's not my strong side, and especially not if they have to be measurable (which good goals should be, rather than your boss evaluating whether or not you did something), but here goes: Goals could be "Pick up language X in order to help development on project Y" or "Get formally introduced to all R&D team leaders, and get introduced to their roadmaps" or "Facilitate 10 job interviews together with team leaders in marketing"
- taivokasper 8y agoThank you. I asked because in the previous company I worked for we had difficulties setting measurable goals for devs and ended up tracking only product goals.
- sjg007 8y agoProduct can be highly variable (or uncertain) so dev goals would focus on skills necessary to achieve said product. Ideally these skills a general and transferrable. Have you ever read a white paper? You see how they manage to say that the product will solve every problem you have and nothing specific at all? Same idea.
- weavie 8y agoI had this when I worked at a large enterprise several years ago. If I recall correctly we had to state goals for each of 5 major categories and another set of 5 supplementary categories. The categories were things like - deliver customer value, enhance team work, collaborate well across teams and various other enterprise buzz words, I forget exactly.. As a coder, my goal was pretty much to write good code and avoid sitting through pointless meetings as much as possible (a very hard task in that place). I would basically have to spend half a day coming up with various different ways to word this so that it would fit each of the five goals. Every six months (one mid year review, and then the final review) I would have to meet with my manager to provide evidence that I was achieving my goals. That would be another half a day twisting words around to try to fit what I had done to the goals. My manager would have to do the same for me. I was then scored on each of the goals. Then the score was totalled up and was used to determine the salary increase that I would get at the end of the year. We all despised the system. A collective groan would go around the meeting room when it was announced that it was review time again.
- sethammons 8y agoThat's unfortunate (and all too common). Goals should be meaningful to you and the company and be few. Achieving them over time should feel good. And reviews should be an opportunity to show off a bit and learn where you can improve a bit.
- commandlinefan 8y agoMy first "goal-setting" experience (five jobs and 20 years ago) was like this: upper management would define company-wide goals (that ended up being incredibly vague) and their direct reports would define their own goals that supported the company-wide goals, and their direct reports would define _their own_ goals, ad nauseum, until it finally trickled all the way down to me, the lowly programmer. So I took it seriously, read my managers goals, his manager's goals, his manager's manager's goals, all the way up the chain so I could try to define some goals of my own that a) I thought I could actually achieve and b) supported everybody else's goals. I had a lot of things like "increase unit test coverage" and "speed up build times" sort of things in there. My manager reviewed my proposed goals (remember, we were supposed to be defining our own) and rejected all of them, giving me a set of completely unachievable and meaningless goals - mostly related to the "flavor of the day" project that I was already waist-deep in. Things like "reported bugs are down 30%", "my peers consistently rate me as a solid team player" and "project fleebleflub is in production and is consistently producing $100,000/month in revenue" (I'm not kidding). Back then I was young and naive, so I argued with him that these goals were effectively impossible for me to achieve alone and he said, "well, these are 'stretch goals' and that's good". Of course, two months later project fleebleflub was cancelled, I was redirected to a troubled project with tons of bugs and my peers hated me because I was always turning away their requests for help because I was frantically trying to meet my own goals. Performance review time started to loom large and I was starting to have an existential crisis - I had printed out my goals and pinned them to the wall of my cube so I kept them in mind and I knew that I hadn't come anywhere close to achieveing any of them. I was five years out of college and starting to panic: my degree was in computer science, so programming was the only career option I had, but it was starting to look like I was terrible at this. I updated my resume the night before the performance review because I knew for sure I was going to be fired. So I went into the performance review, my manager looked over my goals, said, "well, let's see if we can get this up in the next six months" and that was it; I got a "meets expectations" and kept working there. Lather, rinse, repeat for every single song-and-dance goal-setting/performance-review exercise I've ever been through.
- Macha 8y agoOn an individual level, this feels like a box-ticking exercise at the company I work at. Project goals are hard to set out a year in advance as a developer as there's a good chance that within 6 months the direction is changed yet again from product. Personal career development goals are not really considered. When it gets tied into career progression, you end up with not very productive goals (but easily measurable!) like "Reduce eslint warnings in legacy project X by 50%", because business value are either not easily measurable (how do you quantify better knowledge of the overall system architecture? Bugs not caused? But how do you know the developer didn't just stay in their comfort area/have easy projects this quarter/year? I saved Joe 4 hours on Friday since he didn't have to investigate what the system does with foobars as I had the answer? That just sounds petty. ), or not directly under the developers control (revenue).
- le-mark 8y agoWhen it gets tied into career progression, I've come to the conclusion it's folly to pursue any one companies career progression maze. Because you get corralled into all sorts of sillyness like this; vying for projects with your peers, acrimonious code reviews, chasing silly metrics, etc. I find it's much more effective in time, money and title (and work life balance, and mental health) to simply switch jobs for the higher title. In other words don't fall for the "work your ass off for a possible future bump in pay and title" game many companies play.
- sethammons 8y agoOr find a good company. I've worked hard and gone from mid level (actually slightly lower) to principal over several years at the same, growing company. My responsibilities have drastically changed over time towards greater impact and my pay is nearly 3x from where I started.
- seanmcdirmid 8y agoThe same could simply be accomplished with good people management. A good 10X people manager is worth their weight in gold.
- scarface74 8y agoMy experience is that the difference in raises between an employee that got an “Exceeds Expectations” and one that “Meets Expectations” isn’t significant enough to be worth wasting the time worrying about it. The best way to make more money is to change jobs. Google may be different.
- webmaven 8y agoWell, if you exceed expectations, doesn't that mean you didn't set your goals high enough?
- scarface74 8y agoProbably, But working at regular non SV companies, I’ve learned just to focus on doing as well as possible while still having a sane work life balance, keeping on top of industry trends and job hopping when my salary and the market were out of whack. Google pays such above market salaries, the strategy would be different.
- skj 8y agoIdeally expectations are relative to your position at the company, not what people think you can accomplish.
- steelframe 8y agoAt Google you are expected to exceed expectations. But seriously, you are evaluated against the role description (software eng? product mgmt?) and your level. If you exceed expectations consistently over several review cycles, you are encouraged to apply for a promotion. The goal is to get you promoted into a role and level where you can consistently meet expectations.
- deleted 8y ago[deleted]
- sjg007 8y agoAhh the Peter Principle. https://en.wikipedia.org/wiki/Peter_principle https://en.wikipedia.org/wiki/Peter_principle
- aaaaaaaaaab 8y agoAh yes! It's not enough if you're great at your job, or even if you do other people's jobs... Instead you have to have this checklist of your quarterly goals, on which you can go through with your engineering manager on biweekly 1-on-1 meetings! And of course you should make a nice spreadsheet and a confluence page documenting your progress, since we're data driven :) Did you fix a major fuckup in some legacy component? Where are the numbers? Ah, then it's not visible enough for a promotion, here's your 1% raise instead. Do you see Paul over there? He made great progress this quarter! One of his goals was to write a blogpost each week, and guess what, he did! He's on a great growth trajectory, and well deserves his promotion. Long story short: it's a great way to drive away your best talent while keeping the confluence page and blogpost writers.
- hopler 8y agoIt's OK if we lose people who don't care about contributing to the organizational goals and coordinating with teammates, who just want to mess around on whatever amuses them.
- aaaaaaaaaab 8y agoW-hat? Where did you get that from? I'm telling you, fixing a serious issue in a legacy component is anything but amusing. I'd be happy writing blogposts about the current framework of the week, but if I uncover an issue while working on my regular tasks, I'm gonna try to fix it instead of sidestepping it.
- matwood 8y ago> Did you fix a major fuckup in some legacy component? What if that legacy component was no longer in use? Is there some bigger picture in play? I've been at bad companies before, so I understand being cynical. But, having people just do whatever they feel like also does not work. From the outside it looks like Google has quite a bit of this, so they are clearly trying to get people on some path. The messaging app situation shows it hasn't quite worked yet (from the outside anyway).
- 8y ago
- xw1001 8y agoMostly negative experiences: 1) While writing up the goals, you don't have a full view of the problem. Goals change, but once written down, there is a strong pressure to implement what has been written down. 2) It selects for people who are good at writing convincing design docs. Often these people write sub-optimal code and the designs only look good on paper. Actually, the products (aside from search+ads) that come out of Google look exactly like the have been produced using this methodology; and that's not a good thing.
- skj 8y ago> people who are good at writing convincing design docs. Often these people write sub-optimal code and the designs only look good on paper. In my experience, the ones who write good design docs are the ones who write good code. Design doc writing is not simply overhead and marketing - it is concisely describing what and how you want to do something, and inviting feedback and other ideas. The exercise of writing a good design doc brings you through the process, thinking of every non-trivial aspect. It also typically only takes a day or two (or maybe a week for something more complicated) - far less time than the corresponding code takes. And if a colleague points out something that could be done better, you won't have wasted weeks or months writing the wrong code - only hours writing the wrong design. Much less costly to fix, and much easier to move on from, emotionally.
- webmaven 8y agoMy understanding is that OKRs at Google are visible throughout the org, and coleagues are able to (and do) provide feedback on them. Most orgs that adopt OKRs only make them visible to the person's manager, and without transparency and good feedback, the other problems mentioned here proliferate.
- auiya 8y agoThis is simply part of how they've implemented Jack Welch's Vitality Curve[1]. It's pretty common practice for most large companies, although I understand more and more are starting to move away from this approach. As it turns out, most people don't enjoy playing Game of Thrones with their co-workers every quarter. [1]https://en.wikipedia.org/wiki/Vitality_curve https://en.wikipedia.org/wiki/Vitality_curve
- sjg007 8y agoOKRs are straight out of Andy Grove from Intel. If you read further along, the author indicates that getting fired from Google is very rare. So it's not a fire the bottom 10% every year.
- auiya 8y agoAndy and Jack knew each other well. Where do you think Andy's strategy came from? It's the same thing as Jack's Vitality Curve, only without firing the bottom 10%.
- Radim 8y agoBuried in the "2.11 Frequent rewrites" section, but a great hack for "productivity via a sense of ownership": "In addition, rewriting code is a way of transferring knowledge and a sense of ownership to newer team members. This sense of ownership is crucial for productivity: engineers naturally put more effort into developing features and fixing problems in code that they feel is “theirs”."
- yakshaving_jgt 8y agoThanks for highlighting this. To me it seems an important idea that contradicts conventional wisdom, similar in the way that most people over-encourage DRY, blind to the fact it increases coupling.
- lugg 8y agoI frequently find myself drastically refactoring code to understand it. I don't commit those changes because it's not worth the effort to justify the cleanup to people who treat these rules as gospel. Apparently me spending half a day reading code is no big deal but cleaning it up is a waste of time. Shrug.
- quietbritishjim 8y agoI think the objections to rewriting code are sometimes justified, rather than just blindly following rules. As you said, refactoring code helps you understand it. This means that you can end up feeling like your code is objectively clearer than before you started, but sometimes it's just an illusion caused by the fact that you just (re)wrote it. If there are other people in the company that already understand that functionality, you're disrupting the effort they put into understanding the old version of the code. Combine this with the risk of introducing bugs or missing some obscure bits of functionality, and there is valid reason to object. I find this is particularly common mistake by junior programmers (not saying this applies to you), presumably because they aren't used to reading other people's code. Frustratingly, this is often coupled with an attitude that missing out large chunks of existing user functionality is acceptable if it makes the code a bit simpler. Of course, sometimes rewrites/refactors really are an improvement. Sometimes code really is fragile and confusing, either because of who wrote it or because it has had many small changes tacked on in the easiest places. Or perhaps the last person that understood that code has left the company, so it's OK that you find the code clearer only because you just wrote it! But in any case, it is fair to ask for real justification for a rewrite.
- growtofill 8y agoPrevious discussion: https://news.ycombinator.com/item?id=13619378 https://news.ycombinator.com/item?id=13619378
- thatfrenchguy 8y agoThis all looks nice and perfect, but what's the catch ?
- Izmaki 8y agoThat at the end of the day, this is all controlled and used by human beings, who are notoriously known for sometimes being mean and selfish? Examples: the 80/20% project work that is described is a really good idea IMHO, however if somebody choses to work 50/50 in a period, becuase that person is "almost finished and longing to present it", then it might turn into a problem for the team leader and the employee. Software sometimes fails, even highly sophisticated build automation. Rewriting software may introduce a sense of ownership to employees, but it may also lower the quality of the code that is being rewritten - worst case to the extend that the code needs another rewriting to even function as intended. ...but why let yourself get blocked by the negatives, instead of being inspired by the positive?
- steelframe 8y agoFor most people, the catch is that you can't pass the interview loop.
- weinzierl 8y agoWhat I don't understand is how they accomplish larger collaborative changes. The paper says: "Almost all development occurs at the 'head' of the repository, not on branches." Googler Rachel Potvin made an even stronger statement in her presentation about "The Motivation for a Monolithic Codebase" [1]: "Branching for development at Google is exceedingly rare [..]" In the related ACM paper she published with Josh Levenberg there is the statement that: "Development on branches is unusual and not well supported at Google, though branches are typically used for releases." I my world when we have to make a bigger change we create a branch and only merge it into the trunk when it is good enough to be integrated. The branch enables us to work on that change together. I don't understand how they do this at google. As far as I understand in their model they either have to - give up on collaboration and always have just a single developer work on a change. - share code by other means. - check in unfinished work to the trunk for collaboration and constantly break trunk. [1] https://youtu.be/W71BTkUbdqE?t=904 https://youtu.be/W71BTkUbdqE?t=904 [2] https://cacm.acm.org/magazines/2016/7/204032-why-google-stores-billions-of-lines-of-code-in-a-single-repository/fulltext# https://cacm.acm.org/magazines/2016/7/204032-why-google-stor...
- mateuszf 8y agoYou don't have to check in unfinished work, you can break your work in parts and make people work on independent parts, every one of which moves progress forward incrementally. Well, you could actually call that "unfinished" because in the beginning the code doesn't accomplish the task, but progressively it will become more useful.
- weinzierl 8y ago> you can break your work in parts You can when you can but you can't when you can't. I 100% agree with you that we should work this way whenever possible and we should work hard to keep our code in a state that lets us cleanly divide work. In my experience it is not always possible to split up work that way. Think of untangling dependencies of a larger part of the code as an example.
- 8y ago
- patothon 8y agoNot worth a long discussion, but is the Blaze build system they are referring to in fact Bazel?
- Cursuviam 8y agoBlaze is the internal version, such as borg vs kubernetes
- puzzle 8y agoExcept that Blaze/Bazel share code, are very similar and converging over time. The plan is for Google to use Bazel+extensions at some point in the future. Borg and Kubernetes don't share code (they are written in different languages: C++ and Go), look similar only from a very high level perspective and are diverging over time.
- skj 8y agoRight. It's better to say that kubernetes was designed by people who were heavily influenced by borg.
- weinzierl 8y agoBazel started from open sourced parts of Blaze but also added its own features. What I understand from public sources is that Blaze doesn't support external dependencies which Bazel does.
- laurentlb 8y agoYes. Blaze is the name of the binary inside Google. 90% of the code is in common. Differences are 1. integration with Google-internal tools, and 2. legacy misfeatures we plan to remove. (I work on Bazel)
- jokh 8y agoWhat kind of internal integrations, if I may ask? Does it automatically deploy code for you on a successful build or something like that?
- thetechlead 8y agoI used to be proud of many things in the article when working at the G. Not anymore. Let me talk startup anti-Google pattern here. * Most of Google’s code is stored in a single unified source-code repository, and is accessible to all software engineers at Google This can be the worst nightmare from a management POV in a startup. Sure it sounds wonderful everyone can see/fix anyone else code but 99% people shouldn't have time to do so (if they do their work load is not full, increase the load). The 1% I guarantee all your codebase has just been stolen by an ex-employee with malicious attempt. Instead divide your codebase into different projects/roles and people only gain access when needed. * Software engineers at Google are strongly encouraged to program in one of five officially-approved programming languages at Google: C++, Java, Python, Go, or JavaScript. We use Go for backend programing and vue (javascript) for frontend. Don't use Java if possible, keep away from C++ and definitely never Python which is a maintenance nightmare. * The next step is to usually roll out to one or more “canary” servers that are processing a subset of the live production traffic. Not necessary when your misery not-product-market-fit-yet website only gets 100 users. Just roll-the-f-out , let it break and fix later. Building the canary system is a huge overkill in the early stage. * All changes to the main source code repository MUST be reviewed by at least one other engineer. Same as above. Just build and RTFO.
- hoffs 8y agoWhy are you comparing stuff that works at big company with a lot of users and stuff that is pretty much required at a company like that, to a startup?
- hknd 8y agoHow does it make sense to compare the processes of a company with >100k people touching code and products with more than 1B qps, to a startup with <5 people touching code? This comparison makes absolutely no sense.
- thetechlead 8y agoBecause there are people who think things work at Google must work magically for their company. There are many patterns that seem perfect in theory but fail miserably in the real world. Always think different and take nothing for granted.
- dekhn 8y agoI was the maintainer of a third-party library used by thousands of dependent applications at Google. I have to admit, I still have not seen on the outside a system that allows me to change the version of numpy, and know that thousands of dependent applications either work or break, within an hour of making my change. Being able to write and use a mapreduce with a high level of confidence that my code would continue to work years later was another nice benefit. MRs I wrote in the first year at Google still compiled and ran with minimal changes almost 10 years later(!) which is amazing given the amount of environmental change that occurred. That said, somebody could still halt development across the company by changing and checking in a core file (like proto defs for websearch) without testing. Whatever social system led to google3/borg and the amazing productivity associated with it, it was a special moment that hasn't been replicated many times.
- shereadsthenews 8y agoPeople who like multirepos are always saying how easy it is to pin dependencies but like you I haven’t seen anyone doing it right since I left Google. The monorepo third-party system works well in practice. Ps thanks for getting scipy into third_party all those years ago.
- draw_down 8y agoWhat’s really strange is how many people in that recent monorepo discussion were advocating for it in the context of a small org. I’ve only encountered monorepo in a large org, where I’m pretty convinced it’s more efficient than the alternative.
- pjc50 8y ago> The monorepo third-party system works well in practice. It's worth noting that this is only viable at Google because they don't use git. Git's insistence on every client having a full copy of all history of every file in the repository makes monorepo much more expensive. I see conflicting reports over whether google use Perforce or something proprietary called "piper"?
- 8y ago
- bsvalley 8y agoOther than the 20 percent free time, compensation and offices, the engineering culture at Google doesn’t seem to have anything special based on this well written pdf. It is in fact very similar to other large tech companies. Just in case you were still wondering what really attracts great engineers.
- yifanl 8y agoI'm not sure what you could do to improve engineering culture beyond making your office a little bit nicer without starting to take away from life outside the office.
- bsvalley 8y agoYou can innovate in many different areas. For example code reviews, CI/CD pipelines, sharing knowledge across the organization. It seems that Google as a pretty solid engineering culture but it doesn't really innovate much like a lot of other large tech companies. Standards are meant to be broken.
- joshuamorton 8y agoI mean, google was the innovator for many of these practices. They originated Gerrit and no code review tool comes close to critique, although GitHub and co are catching up. A lot of the innovation (kythe, grok) isn't mentioned here, but is necessary.
- hknd 8y agoI think it attracts a lot of great engineers that they can (mostly) work on something which is used by billions of users. You can basically improve the life of 1B ppl by writing code. Also: having a FAANG company in your CV makes it super easy join any other tech company.
- bsvalley 8y agoReality is that most of the engineers at Google don't work on google search nor google map. They work on "smaller" projects that don't necessarily reach billions of users. It doesn't change the fact that everything has to be engineered in order to work for a large amount of users, true, but do you really get that reach? nope unless you're in a very hot and selective team at G. Also, your statement is valid for companies like Facebook, Uber, Apple, Amazon, etc. It is not a valid argument anymore in my opinion. But I totally get your point.
- lexpar 8y agoThe protocol buffers stuff seems pretty cool. At my last job (small web dev shop), we had constant headaches over the class definitions of endpoints changing and some js file not having its model updated to correspond. I thought we should be writing XML files that both ends could be reading in - we never got up the political will to make that big change though. https://developers.google.com/protocol-buffers/ https://developers.google.com/protocol-buffers/
- gradys 8y agoYep, protocol buffers are like a cross-language type system for the data that moves between systems with the side benefit of compact serialization. They're awesome and definitely a big productivity boost above a certain scale.
- lexpar 8y agoSomething like this would have indeed saved us a lot of time in the long run. Oh well.
- isseu 8y agoI was not a big fan of monorepos until I work at a large company that use them. The use of a monorepo and protocol buffers make communication between systems soo much easier.
- alexandercrohde 8y ago>>Most software at Google gets rewritten every few years. >> This may seem incredibly costly. Indeed, it does consume a large fraction of Google’s resources. However, it also has some crucial benefits that are key to Google’s agility and long-term success. Uh... No? Chrome, gmail, search, youtube, analytics, android, documents all usually have 2 or 3% functionality changes each year. What a ludicrous proposition stated so matter-of-factly.
- throwawaymath 8y agoIs it possible most software at Google is not Chrome, Gmail, Search, Youtube, Analytics, Android or Documents? Also do you work at Google? If you don't, you might not be able to perceive all the changes to those applications on the backend. The user interface may change at a more constrained pace, but it can still be true that most backend code is in a constant state of revision. For example, what defines "Search" in your example? The google.com search interface rarely changes (logo notwithstanding), but what do we have to go on for how often search infrastructure or processing code changes?
- alexandercrohde 8y agoLet me be clear (and I don't work at google). I'm not saying google doesn't spend a lot of engineering time doing rewrites. I'm saying if google DOES spend a lot of the engineering time of its 20,000 engineers doing rewrites that is BAD by all measures. Maybe it would explain how a company with 1,000 startups worth of "top-talent" engineers could not produce any new functionality in the last 5 years though (small exception of AI)
- wolco 8y agoThis is a good point worth exploring. If google has 1000 startups worth of talent (which is another point worthdiscussing) the corporate structure has clearly slowed down new functionality or new product ideas. It seems like it is 1000 times harder at google which levels the playing field.
- 8y ago
- TagAsDelusion 8y agofad driven development makes ephemeral products
- stillworks 8y agoSo, the thing that is still buzzing in my head now and not mentioned in the article (maybe I didn't read carefully enough), what actually gets released into prod after a change is reviewed and merged. If the monorep contains let's say five different products and in a day only one of them gets a merge, then Blaze still builds all five and all five are released (based on successful integration testing)? OR only releases the changed product (and any other ones which depended on the changed one) EDIT: Also, the "canary" server is still for testing ? There may exist practically a set of canaries running very different versions ? Is there any correlation or any version "roll-up" constraints between various canaries ?
- kyrra 8y agoReleases are controlled by each team. For example, my team has multiple binaries that run in production. Some of them are stable and don't receive any active code changes but are pushed every time we do a release. But for those that don't get direct code changes, they will still pickup any changes to shared libraries. Canaries are live/production traffic only. When a release is deployed, it goes to the canary instances of a job first, and it will take a small subset of traffic. This allows the job owners to see if the new binary has any adverse effects before rolling out more widely. More details about canaries can be found here[0]. Once important thing to think about with Google's source control is that it is closer to SVN as far as versioning goes. There are no (for the most part) feature branches or anything like that. Everyone is always working on HEAD. when you do a release, you will start near HEAD when cutting the release. [0] https://landing.google.com/sre/sre-book/chapters/testing-reliability/ https://landing.google.com/sre/sre-book/chapters/testing-rel...
- ASinclair 8y agoLike kyrra said. Releases are handled by independently by each team. Teams are in various states of maturity in relation to their release practices. Some are fully automated. Some involve manual QA. I've supported teams across that continuum as a SETI at Google. I'm not as well-versed in canarying though I've set it up for a team or two. I've only ever seen a single canary version for any particular binary. Canarying is done. I haven't seen canaries running multiple versions of the same binary. Though teams will often guard new behavior behind experiment flags.
- diaktifkan 8y agoWhich part discusses what Does with your IP when you're not sitting in the office?
- auiya 8y agoPage 17 - "any employee can nominate any other employee for a 'peer bonus' - a cash bonus of $100 - up to twice a year..." Is there a hard cap/limit on this policy now? I might have to take the rap for that, having peer bonus'd my entire office on my last day there back in 2012. My bad.
- joshuamorton 8y agoI think that's "you can nominate a specific other person twice a year". There's a soft cap on how many people you can nominate per year period, but its pretty high.
- cpeterso 8y agoI'm curious to learn more about Google's approach to project planning and management, beyond OKRs for personal or team goals. Do all teams use the same standard process or are teams allowed to do their own thing? What tools and cadence do they use to track project milestones and progress? With Google's monorepo and a centralized bug tracker, they could make some nice project dashboards.
- lucasmullens 8y agoEach team does their own thing. There's some project management tools that are popular, but no Google-wide standard.
- d_burfoot 8y agoI opened this document expecting to have my mind expanded by learning about amazing new techniques for high-level software engineering. I was disappointed. A lot of it just seems to be about release engineering. Yeah, sure, release engineering is really hard and important for a company like Google, but it's of limited general interest. I was particularly disappointed by Google's indifference to the use of smarter languages than the Big 5 (C++, Java, Python, etc). As an example of something that did expand my repertoire as a software engineer, check out this article by Jane Street: https://blog.janestreet.com/testing-with-expectations/ https://blog.janestreet.com/testing-with-expectations/
- dashmug 8y agoWhere's Dart?
- mbrodersen 8y agoSoftware developers that can't work with code they didn't write themselves are not skilled Software developers.