web site hit counter Software Engineering at Google: Lessons Learned from Programming Over Time - Ebooks PDF Online
Hot Best Seller

Software Engineering at Google: Lessons Learned from Programming Over Time

Availability: Ready to download

The approach to and understanding of software engineering at Google is unlike any other company. With this book, you'll get a candid and insightful look at how software is constructed and maintained by some of the world's leading practitioners. Titus Winters, Tom Manshreck, and Hyrum K. Wright, software engineers and a technical writer at Google, reframe how software engine The approach to and understanding of software engineering at Google is unlike any other company. With this book, you'll get a candid and insightful look at how software is constructed and maintained by some of the world's leading practitioners. Titus Winters, Tom Manshreck, and Hyrum K. Wright, software engineers and a technical writer at Google, reframe how software engineering is practiced and taught: from an emphasis on programming to an emphasis on software engineering, which roughly translates to programming over time. You'll learn: Fundamental differences between software engineering and programming How an organization effectively manages a living codebase and efficiently responds to inevitable change Why culture (and recognizing it) is important, and how processes, practices, and tools come into play


Compare

The approach to and understanding of software engineering at Google is unlike any other company. With this book, you'll get a candid and insightful look at how software is constructed and maintained by some of the world's leading practitioners. Titus Winters, Tom Manshreck, and Hyrum K. Wright, software engineers and a technical writer at Google, reframe how software engine The approach to and understanding of software engineering at Google is unlike any other company. With this book, you'll get a candid and insightful look at how software is constructed and maintained by some of the world's leading practitioners. Titus Winters, Tom Manshreck, and Hyrum K. Wright, software engineers and a technical writer at Google, reframe how software engineering is practiced and taught: from an emphasis on programming to an emphasis on software engineering, which roughly translates to programming over time. You'll learn: Fundamental differences between software engineering and programming How an organization effectively manages a living codebase and efficiently responds to inevitable change Why culture (and recognizing it) is important, and how processes, practices, and tools come into play

30 review for Software Engineering at Google: Lessons Learned from Programming Over Time

  1. 4 out of 5

    Sebastian Gebski

    I liked it a lot. If you take a look at the TOC, you may get the impression that this book is some sort of manual to software engineering. It is not. Yes covers all the most important aspects of SE, but it doesn't present you all the basic knowledge from the group up - what it does is presenting Google's PoV & unique challenges and how this organization has solved them. This has quite significant implications - their problems may be very far from your problems. Their solutions may not only be unre I liked it a lot. If you take a look at the TOC, you may get the impression that this book is some sort of manual to software engineering. It is not. Yes covers all the most important aspects of SE, but it doesn't present you all the basic knowledge from the group up - what it does is presenting Google's PoV & unique challenges and how this organization has solved them. This has quite significant implications - their problems may be very far from your problems. Their solutions may not only be unreasonable in your case but even not doable at all. But this doesn't make the book obsolete or uninteresting - quite the contrary. The value of [email protected] is in: * presenting what the engineering (problem solver's) mindset is about * revealing some interesting details - how do companies of such scale do deal with growth & inertia * showing that you should approach problems with pragmatism, not zealotry (because the real-life is all about trade-offs & picking the battles wisely) I've really enjoyed the read. The further, the better. Maybe it was not super-revealing, but I LOVE sharing warstory-like experience & that's what this book has provided.

  2. 4 out of 5

    Angad Nadkarni

    While this book provides a very interesting insight into the problems faced at Google-scale in an organized manner never attempted before, I choose to rate it as a 3 because it isn't (in my opinion) indispensable. The first half is rather weak, not for lack of appreciation for the managerial skill that building good software takes, but because the book provides the same old cliches that most in software would have come across without providing substantially more motivation. Most of the takeaways While this book provides a very interesting insight into the problems faced at Google-scale in an organized manner never attempted before, I choose to rate it as a 3 because it isn't (in my opinion) indispensable. The first half is rather weak, not for lack of appreciation for the managerial skill that building good software takes, but because the book provides the same old cliches that most in software would have come across without providing substantially more motivation. Most of the takeaways are a few bullet-points at most. My other problem with the book is its (self-announced) myopia to Google. To most novice engineers who haven't themselves run into some of the problems described in the book, the motivations will continue to remain unclear and solutions further obfuscated within the Google-context/parlance. It is entirely possible I was reading it too lazily, but I personally find a barrage of case-studies of unrelated products rather tiring, especially when the content isn't organized in a way where the takeaways are clear. The second half picks up pace well as it is technical, and clearly closer to the author's day at Google than the former. I found some of the paradigms employed at Google very interesting as to stumble upon them online in one singular place is unlikely, so this book is your best bet. In summary: > If in your journey as a software engineer, you are yet to acknowledge software as a living, breathing thing, you will find little to no value for yourself in this book. > If you are at a point where you are seeing some scaling issues with your team or engineering process, this book is a must-read because it can provide for a few new paradigms. > If you are in a large traditional business, you will continue to remain in awe of Google and leave this book without too many actionables. > If you are in a large tech business, you likely don't need this book because your bootcamp covers it; however, it'll be a fun read! Think of it like a very interesting conversation for hours with a Google engineer. He's smart and really experienced, but also incapable of any imagination outside of the Google box.

  3. 4 out of 5

    Ioana

    Google is probably the most representative company in software engineering today, and also one of the most stable ones when it comes to organisations that recognise and respect the craft. They've been going steadily for over 20 years, and have been pioneers when it comes to strategies on how to build programmes sustainably and reliably. Naturally, I was keen to learn from their experiences as well, and here are some things I picked up: - Cost encompasses finances, resources, personnel and transac Google is probably the most representative company in software engineering today, and also one of the most stable ones when it comes to organisations that recognise and respect the craft. They've been going steadily for over 20 years, and have been pioneers when it comes to strategies on how to build programmes sustainably and reliably. Naturally, I was keen to learn from their experiences as well, and here are some things I picked up: - Cost encompasses finances, resources, personnel and transactions (what does it cost to take action); - In creative fields, finances are usually not the limiting factor; - Behavioural principles: humility, respect and trust; - The social game is not about politics, it's about creating relationships to get things done; - Not failing means you're not being innovative enough; - Testing on the Toilet and Learning on the Loo - love a catchy name; - 1-2% of Google engineers are readability reviewers for programming languages and they operate as volunteers; - Don't build for everyone, build with everyone; - Creatives need nurturing, time and space to think and create; - Hope is not a strategy - build for failure handling; - Goals/Signals/Metrics to guide metrics creation; - Tests begin to lose value at 1% flakiness; - Hyrum's Law: the customer usage of your API speaks the truth, not your intended use; - Use third party APIs as seams for tests; - Deprecation warnings should have actionability and relevance - don't really on the customer to deprecate it for you; - UI is considered responsive if latencies are below 200ms; - You can avoid becoming dependent on your public cloud solution via using open-source, build tooling on top of it, or using a hybrid (even between 2 publics or a public and a private). Overall, great read, especially the chapters on Code Reviews, Dependency Management and CI/CD. Easy to read, yet thorough and with plenty of examples of issues that Google dealt with, both in technical depth as well as business depth. Highly recommended and one where I will keep looking at my annotations!

  4. 5 out of 5

    Prasanna

    Pretty interesting look into what Google's software engineering looks like. A huge chunk of the book can be described into few principles * Hyrum's rule: If you expose anything in your API someone's going to use it. Both internal and external ones * Beyonce rule: If you liked it enough, should've put a CI test on it. ie, it's not infrastructure change's fault if CI didn't catch it. * Make it easy and build tooling for large scale changes because languages change, systems update * Upgrade early, upgr Pretty interesting look into what Google's software engineering looks like. A huge chunk of the book can be described into few principles * Hyrum's rule: If you expose anything in your API someone's going to use it. Both internal and external ones * Beyonce rule: If you liked it enough, should've put a CI test on it. ie, it's not infrastructure change's fault if CI didn't catch it. * Make it easy and build tooling for large scale changes because languages change, systems update * Upgrade early, upgrade often Another thing this book does well is to go over the build system Bazel. Having used it in the past for some open source projects I had familiarity with it but this book provides a pretty concise explanation of what an artifact based build system looks like. Unfortunately for Go, it still doesn't quite fit very nicely. But the idea that you can remotely execute your build stages and map it directly into your filesystem is very tempting. Each chapter has a TL;DR at the end which is so great!

  5. 4 out of 5

    Bernardo

    If you have been in the industry for awhile you probably have seen and/or applied many of the concepts explained in this book. Having said that it's still a well written book that covers a wide range of topics. Worth it especially if you have some experience but it's still relatively new to the industry. If you have been in the industry for awhile you probably have seen and/or applied many of the concepts explained in this book. Having said that it's still a well written book that covers a wide range of topics. Worth it especially if you have some experience but it's still relatively new to the industry.

  6. 4 out of 5

    Susan

    It's interesting to read this book as a Google engineer because it makes me more appreciative of the tools I've been using on a daily basis and stop taking them for granted. It's interesting to read this book as a Google engineer because it makes me more appreciative of the tools I've been using on a daily basis and stop taking them for granted.

  7. 4 out of 5

    Mohammad Tanviruzzaman

    The book is written by build/release/tool people, so the focus is on that part of software engineering that makes the coders more productive - how could the coders build, test, review code better? It does not talk about things like design patterns for example. The code for which the engineering ideas are targeted is assumed to live long, like for decades. The book is divided into three parts: (1) Culture (of learning) (2) Process (strong code review and testing) and (3) Tools (critique, piper, r The book is written by build/release/tool people, so the focus is on that part of software engineering that makes the coders more productive - how could the coders build, test, review code better? It does not talk about things like design patterns for example. The code for which the engineering ideas are targeted is assumed to live long, like for decades. The book is divided into three parts: (1) Culture (of learning) (2) Process (strong code review and testing) and (3) Tools (critique, piper, rosie, borg... - names are cool). The book talks about so many ideas that it is hard to imagine that other software houses have done all of those or they may not have done it in the same way which leaves food for thought. For example, put docs in the same repository side-by-side with code, both using the same workflows (as an extension why not have unit tests for the code snippets in the docs as well?) Code review is a turn-by-turn game, making it easy to find whose turn it is and what s/he is supposed to do should help a lot. The idea of monorepo is interesting (I cannot say I fully understand all its greatness yet). Feature flags let features be less coupled with binaries. The code is read optimized and the Readability process is crucial. Hyrum's law - that with a large enough userbase of an API a seemingly innocuous change breaks someone - is a recurring theme in the book. Compute infra should behave and be treated like cattle not pets. Code is liability, useful features are assets - being able to provide useful features with 0 lines of code should be ideal. In the last chapter, the authors talk about compute as a service and the approach there is to start with the manual installation or fix on a single machine and grow from there naturally. The book as a whole, if followed the pattern from the last chapter, would have been way more awesome.

  8. 5 out of 5

    Scott J Pearson

    Relatively little is known about how to organize/manage software projects so that they come to a successful, on-time resolution that lasts the test of experience. This is the field of software engineering, and over the last two decades, Google has mastered this art. They share their hard-wrought wisdom in this book. Many developers, like me, wish they could undertake several internships at leading companies like Apple, Google, Microsoft, or Facebook. They could learn the tricks of the trade from Relatively little is known about how to organize/manage software projects so that they come to a successful, on-time resolution that lasts the test of experience. This is the field of software engineering, and over the last two decades, Google has mastered this art. They share their hard-wrought wisdom in this book. Many developers, like me, wish they could undertake several internships at leading companies like Apple, Google, Microsoft, or Facebook. They could learn the tricks of the trade from what made these entities so successful. Concerning Google, software developers now can just consult this book. It provides an in-depth look into the state of the art at this engineering company. Each chapter is written by company experts and covers 25 timely topics ranging from code testing to dependency management, from continual integration to cloud services. Google is one of only a few companies that have broached these issues in depth ever. They do not claim that their answers will solve all problems for all time. Rather, they encourage readers to learn from their well-reasoned thoughts and understand their own problems in that light. This book is relevant to the start-up as well as the corporate developer. For us computer programmers, this book is fodder and inspiration for continually producing better software. I find the quality of writing particularly fresh. Instead of hiding behind older and well-established verbiage, they provide newly thought-out terminology in newly explained reasonings. For a technical book, this work is extremely engaging. The reader rarely if ever gets the sense that the authors are merely regurgitating rehashed theory. This book is particularly relevant to software developers and managers of software efforts. It gives a lingua franca to the software development effort and provides abstracted concepts that will help companies move development forward. All the way to the end, I stayed engaged, and I predict many others will, too. Kudos to Google for giving back to the industry in this way!

  9. 5 out of 5

    Pawel Waclawczyk

    It was a long journey for me to read this book. I enjoyed a number of parts, especially the ones of leadership and management, as well as more technical chapters about testing. Not all essays of tools were that fascinating to me at the time of reading. Yet, I love the "engineering" approach maintained through this book. Also, the ability a look closer at a big company like Google and see their day-to-day challenges and solutions was quite a pleasure and good learning time. It was a long journey for me to read this book. I enjoyed a number of parts, especially the ones of leadership and management, as well as more technical chapters about testing. Not all essays of tools were that fascinating to me at the time of reading. Yet, I love the "engineering" approach maintained through this book. Also, the ability a look closer at a big company like Google and see their day-to-day challenges and solutions was quite a pleasure and good learning time.

  10. 4 out of 5

    Julien Sobczak

    Following the success of the SRE book series, an inside look on the other side of the looking-glass. Google is unique and few companies have to address engineering problems at Google scale. All programmers, however, will learn valuable lessons acquired during two decades where Google built some of the most innovative applications, and the underlying platform to make them come to life. The book reintroduces the term engineering with a new definition: programming integrated over time, or how to mak Following the success of the SRE book series, an inside look on the other side of the looking-glass. Google is unique and few companies have to address engineering problems at Google scale. All programmers, however, will learn valuable lessons acquired during two decades where Google built some of the most innovative applications, and the underlying platform to make them come to life. The book reintroduces the term engineering with a new definition: programming integrated over time, or how to make software programs stand the test of time. You will find in this book how tens of thousands of engineers collaborates across the same codebase, in an quite unusual way. The first part is relatively short and focuses on Google engineering culture. The second part is about processes and presents common software development practices, like automated testing. I found few things that are not already discussed elsewhere in the literature, even if Google’s scale presents new challenges. These chapters are extremely well written and clarify many misunderstood points like the usage of test doubles. I hope that having Google printed on the book cover helps those practices spread even further. The last part is about internal tools used by Googlers. This is the largest part, and also the part I found the most interesting. The chapter on dependency management is really excellent and does a remarkable job in introducing their monorepo approach. More diagrams, screenshots, or pictures (like a Testing on the Toilet flyer) would have been appreciated (especially concerning the chapters about CI/CD and large-scale changes). It’s a large book with almost no code, as it has more to do with engineering than programming. It’s a book about Google. You may not want to apply the same techniques in your organization, and that’s totally fine. But you cannot ignore fresh perspectives on our discipline to help us deliver even better software. I liked this book and I would like other large-scale companies to put on paper their practices too.

  11. 4 out of 5

    Ahmad hosseini

    Think about whatever challenges you have at software development and software engineering, attach to it an “at large scale” phrase, and then you could sense what the book is about. Discussions in this book are more about software engineering and less about programming. So there are a lot of topics about managing codes, tests, and programmers in large scale. Based on the book there are three critical differences between programming and software engineering: time, scale, and the trade-offs at play. Think about whatever challenges you have at software development and software engineering, attach to it an “at large scale” phrase, and then you could sense what the book is about. Discussions in this book are more about software engineering and less about programming. So there are a lot of topics about managing codes, tests, and programmers in large scale. Based on the book there are three critical differences between programming and software engineering: time, scale, and the trade-offs at play. So in software engineering we should consider changes through the time and accept the trades of our decisions and make the system in such a way that we could scaling it. The book talks about Google's internal culture and processes, and some of the tools developed by Google engineers to address Google's internal challenges. When you think about differences between programming and software engineering consider these three sentences: Programming is certainly a part of software engineering. Software engineering isn’t programming. Software engineering is programming integrated overtime.

  12. 5 out of 5

    David Souza

    This is definitely a book you need to spend some time to really learn from. This book is useful for both people that work at Google and people who don’t. I did 3 internships at Google as a Software Engineer and there were a lot of things I didn’t understand about how things work in the company: processes, tools, behaviors, etc. I wish I read this book before. It prepares you very well so you don’t start completely from zero if you land a job at Google, or as I said, makes you understand the reaso This is definitely a book you need to spend some time to really learn from. This book is useful for both people that work at Google and people who don’t. I did 3 internships at Google as a Software Engineer and there were a lot of things I didn’t understand about how things work in the company: processes, tools, behaviors, etc. I wish I read this book before. It prepares you very well so you don’t start completely from zero if you land a job at Google, or as I said, makes you understand the reason of why things are they way they are if you’re already working at Google. And it’s also very useful for people who don’t work or plan to work at Google, it teaches you a lot of valuable stuff that you can easily use elsewhere. Of course there are some quite complex topics that you might not need, but buying this book will end up as an excellent decision. You’ll learn plenty of useful things reading this.

  13. 5 out of 5

    Madhur Bhargava

    I specifically enjoyed the starting chapters where the author introduced the processes at Google and found those to be very enlightening. However, given the breadth of the book I highly doubt that at a single point in time, all the chapters would be a required read for anyone. For example, I am an experienced mobile developer and hence was able to quickly breeze through chapters regarding - Larger tests - since it was of little relevance for my case. Version control - already had some idea of thi I specifically enjoyed the starting chapters where the author introduced the processes at Google and found those to be very enlightening. However, given the breadth of the book I highly doubt that at a single point in time, all the chapters would be a required read for anyone. For example, I am an experienced mobile developer and hence was able to quickly breeze through chapters regarding - Larger tests - since it was of little relevance for my case. Version control - already had some idea of this one. Same may be suited for many of the reading cases. Also, I found a few chapters as being redundant such as the chapter on the code review tool. But anyhow, it is a good book to get a glimpse of things at Google.

  14. 4 out of 5

    Emily

    Very well organized. Much more technical than I expected, definitely only interesting to people in the industry. The content talked a great deal about culture and path to the current environment and toolset at Google. This was a well edited collection of content, gathered from many people but very readable throughout and at a consistent depth. I loved the TL;DR summaries at the end of chapters and found it to be a succinct summary the contents for chapters I read in depth. For chapters I skimmed Very well organized. Much more technical than I expected, definitely only interesting to people in the industry. The content talked a great deal about culture and path to the current environment and toolset at Google. This was a well edited collection of content, gathered from many people but very readable throughout and at a consistent depth. I loved the TL;DR summaries at the end of chapters and found it to be a succinct summary the contents for chapters I read in depth. For chapters I skimmed, the TL;DR allowed me to go back and review in more depth any areas I might have missed. Definitely take time to review the detailed table of contents prior to investing in this book. Note: I requested this from my local library and they purchased it for me.

  15. 5 out of 5

    Roman Safronov

    TL;DR Must read, if you're involved in scaling the software product-centric organization. The book provides a lot of relevant information, though many examples and recommendation require reader to have certain experience to appreciate them. Things I found to be interesting: * Hyrum's Law * "Code is a liability, not an asset" way of thinking * Focus tests on state instead of interactions (somewhat controversial) * Real Dependency -> Fake -> Stub: each step reduces fidelity of test (especially interesti TL;DR Must read, if you're involved in scaling the software product-centric organization. The book provides a lot of relevant information, though many examples and recommendation require reader to have certain experience to appreciate them. Things I found to be interesting: * Hyrum's Law * "Code is a liability, not an asset" way of thinking * Focus tests on state instead of interactions (somewhat controversial) * Real Dependency -> Fake -> Stub: each step reduces fidelity of test (especially interesting was the comparison with test pyramid) * "One-Version" Rule for dependency management

  16. 4 out of 5

    Dylan Meeus

    This book should be mandatory to read for software engineers. Not all of it is perfect, but in general it gives a good idea about software engineering at scale. Plus a lot of it is applicable no matter the size of the codebase. I do rate it 4/5 stars because by appealing to a large audience, some chapters are rather basic. On top of that, the few chapters that talk mainly about internal tools at google are not applicable at all unless you work there. As an experienced eng myself, I still at just This book should be mandatory to read for software engineers. Not all of it is perfect, but in general it gives a good idea about software engineering at scale. Plus a lot of it is applicable no matter the size of the codebase. I do rate it 4/5 stars because by appealing to a large audience, some chapters are rather basic. On top of that, the few chapters that talk mainly about internal tools at google are not applicable at all unless you work there. As an experienced eng myself, I still at just under 80 highlights / notes on my kindle when reading this. Definitely worth it.

  17. 5 out of 5

    A sal

    If you work in SW its a must read, which its pretty obvious given that Software is the first word on the title. But what I found eye opening is the large scale and long term perspective that Google leaders are putting into the development process. Great focus is given on reducing the "waste" of cognitive energy in processes like verification, dependencies and even code browsing. The book is a difficult read at times, but it is great to know about the state of the art on programming practices, or If you work in SW its a must read, which its pretty obvious given that Software is the first word on the title. But what I found eye opening is the large scale and long term perspective that Google leaders are putting into the development process. Great focus is given on reducing the "waste" of cognitive energy in processes like verification, dependencies and even code browsing. The book is a difficult read at times, but it is great to know about the state of the art on programming practices, or to say it correctly, "software engineering" practices.

  18. 4 out of 5

    Paweł Rusin

    It seems like this book was released a couple years too late to be really impactful, as most of the solutions presented here already penetrated the industry to the great extent. Also, since every chapter was about completely different topic, most of them didn't get into enough depth for my taste. Chapters on branching, build system and dependency management were great though and challenged some of my ideas on how to build software! It seems like this book was released a couple years too late to be really impactful, as most of the solutions presented here already penetrated the industry to the great extent. Also, since every chapter was about completely different topic, most of them didn't get into enough depth for my taste. Chapters on branching, build system and dependency management were great though and challenged some of my ideas on how to build software!

  19. 5 out of 5

    Łukasz Słonina

    Authors are sharing engineering practices form company with thousands of programmers, software engineers. If you're part of such organization or you're just curious how such organizations are working then this book is for you. Reads very easily. You would learn not only how Google is working (CI, CD, monorepo, code review practices) but you would also understand why they picked particular approaches. Authors are sharing engineering practices form company with thousands of programmers, software engineers. If you're part of such organization or you're just curious how such organizations are working then this book is for you. Reads very easily. You would learn not only how Google is working (CI, CD, monorepo, code review practices) but you would also understand why they picked particular approaches.

  20. 5 out of 5

    AnhDuc

    One of the best book I've read on Software Engineering. It changes my view a lot on certain topics (For example, documentation management, what's software engineer, version control, leadership...). I'd recommend this book to any Software Engineer because each chapters have something to offer, and their advices fit really well to large-scale long-term problems. One of the best book I've read on Software Engineering. It changes my view a lot on certain topics (For example, documentation management, what's software engineer, version control, leadership...). I'd recommend this book to any Software Engineer because each chapters have something to offer, and their advices fit really well to large-scale long-term problems.

  21. 5 out of 5

    Yixing J

    This book is gold, especially the first chapter. I used to be an engineer which is "too pragmatic", with the mindset of just getting it to work, and could be producing hacky solutions at times. But after reading it I care much more about "software engineering". Software engineering is programming integrated over time. Try to aim for software that can live for a long period of time. This book is gold, especially the first chapter. I used to be an engineer which is "too pragmatic", with the mindset of just getting it to work, and could be producing hacky solutions at times. But after reading it I care much more about "software engineering". Software engineering is programming integrated over time. Try to aim for software that can live for a long period of time.

  22. 4 out of 5

    Damian Zydek

    Great book! It contains practical knowledge from many years of experience in Software Engineering. I think every Software Engineer will find something worth reading. I liked the most chapters about dependency management, sharing knowledge, and automated testing.

  23. 5 out of 5

    Adam

    This was extremely helpful until the chapters on testing. It quickly got outside of my areas of interest around that point, and the tools section was a wash for me. I'd read the first half again, but would need a career change or two before the second half is helpful to me This was extremely helpful until the chapters on testing. It quickly got outside of my areas of interest around that point, and the tools section was a wash for me. I'd read the first half again, but would need a career change or two before the second half is helpful to me

  24. 4 out of 5

    SolidM

    Some chapters are amazing (e.g. unit testing). The rest is pretty much common.

  25. 4 out of 5

    ferhat

    A humble modern manual to software engineering.

  26. 5 out of 5

    Waqar Ahmed

    Valuable in understanding some of the things that you don't realize or consider important. Valuable in understanding some of the things that you don't realize or consider important.

  27. 5 out of 5

    Tianyao Chen

    Interesting read! However, the book is way too detailed in my opinion. I'd recommend this paper (https://arxiv.org/pdf/1702.01715.pdf) instead, which is like a summary for the book:) Interesting read! However, the book is way too detailed in my opinion. I'd recommend this paper (https://arxiv.org/pdf/1702.01715.pdf) instead, which is like a summary for the book:)

  28. 5 out of 5

    Andrew

    Some extremely useful info buried in there, overall not a pleasant read.

  29. 5 out of 5

    Marcus Cramer

    Pretty heavy read, nothing for a light good night enjoyment. Nonetheless, a lot of these concepts can serve as inspiration for the practicing software engineer.

  30. 4 out of 5

    Asdasdasdasda

    Every executive should read this, even if its technical. Great insights!

Add a review

Your email address will not be published. Required fields are marked *

Loading...
We use cookies to give you the best online experience. By using our website you agree to our use of cookies in accordance with our cookie policy.