- Capa comum: 431 páginas
- Editora: Prentice Hall PTR; Edição: 1 (11 de agosto de 2008)
- Idioma: Inglês
- ISBN-10: 0132350882
- ISBN-13: 978-0132350884
- Dimensões do produto: 17,5 x 2,8 x 23,1 cm
- Peso do produto: 771 g
- Avaliação média: 4.7 de 5 estrelas Ver todas as análises (3 avaliações de clientes)
- Lista de mais vendidos da Amazon: no. 55,470 em Livros (Conheça o Top 100 na categoria Livros)
Clean Code: A Handbook of Agile Software Craftsmanship (Inglês) Capa Comum – 10 ago 2008
|Novo a partir de||Usado a partir de|
Leia Enquanto Enviamos
Compre e comece a ler a amostra digital deste livro enquanto espera ele chegar. Saiba mais aqui.
Clientes que visualizaram este item também visualizaram
Quais outros itens os consumidores compraram após visualizar este item?
Faça download dos Aplicativos de Leitura Kindle Gratuitos e comece a ler eBooks Kindle nos mais populares smartphones, tablets e computadores pessoais. Para enviar o link de download para seu smartphone por SMS, use o formato internacional sem espaços (Código Internacional+DDD+Número. Exemplo: +551199999999)
Para receber o link de download digite seu celular:
eBooks novos para sua biblioteca digital. Veja aqui
Detalhes do produto
Descrições do Produto
Noted software expert Robert C. Martin presents a revolutionary paradigm with Clean Code: A Handbook of Agile Software Craftsmanship. Martin has teamed up with his colleagues from Object Mentor to distill their best agile practice of cleaning code “on the fly” into a book that will instill within you the values of a software craftsman and make you a better programmer―but only if you work at it.
What kind of work will you be doing? You’ll be reading code―lots of code. And you will be challenged to think about what’s right about that code, and what’s wrong with it. More importantly, you will be challenged to reassess your professional values and your commitment to your craft.
Clean Code is divided into three parts. The first describes the principles, patterns, and practices of writing clean code. The second part consists of several case studies of increasing complexity. Each case study is an exercise in cleaning up code―of transforming a code base that has some problems into one that is sound and efficient. The third part is the payoff: a single chapter containing a list of heuristics and “smells” gathered while creating the case studies. The result is a knowledge base that describes the way we think when we write, read, and clean code.
Readers will come away from this book understanding
- How to tell the difference between good and bad code
- How to write good code and how to transform bad code into good code
- How to create good names, good functions, good objects, and good classes
- How to format code for maximum readability
- How to implement complete error handling without obscuring code logic
- How to unit test and practice test-driven development
Sobre o Autor
Avaliação de clientes
Principais avaliações de clientes
Avaliações mais úteis de consumidores na Amazon.com
Every programmer regardless of experience should read this book. Thanks!
After having 'clean code' presented to me in video form, I had to Robert "Uncle Bob" Martin's book on Clean Code. It is simply the most effective way to develop and approach development.
From the seemingly mundane ('variable names' and 'number of lines per function') to the advanced ('single responsibility', 'test driven development'), Clean Code covers it all and it would serve young engineers well to adopt a few of these practices.
The suggestions presented in the book (meaningful names, pertinence of comments, code formatting, etc) may sound very familiar to any experienced programmer but they are presented with such a level of detail and with very illustrative examples that it is almost impossible not to learn valuable things chapter by chapter. All the examples are in Java, but the guidelines they illustrate can be applied, in most of the cases, to other languages.
The most challenging chapter to read (but also a very valuable one) was the Refactoring of the class SerialDate (from the JCommon library). It is a real-life example and the author shows step-by-step what it takes to do refactoring. The last chapter, "Smells and Heuristics" makes a very good closure presenting in categories and in a condensed way, potential problems and suggested ways to solve/mitigate them.
I enjoyed reading this book and after finishing it, I decided to apply the Boy Scout Rule. I took a module written in a procedural language and not only managed to improve the clarity of the code, but also reduced the number of lines from more than 1,100 to 650. The next person to touch this code will certainly be happy to deal with cleaner code!
The only negative is that all the code examples are in Java, which I have had very little experience with. He also spends a fair bit of time covering Java-specific techniques. While this is handy for Java programmers, I feel that he loses the rest of the audience during these sections. However, the general techniques he gives can easily be applied to almost any modern language that's used for serious commercial development.