Preço digital sugerido: | R$ 175,30 |
Preço Kindle: | R$ 59,79 Economize |
Vendido por: | Amazon Servicos de Varejo do Brasil Ltda |
Suas inscrições e assinaturas
Baixe o app Kindle gratuito e comece a ler livros do Kindle instantaneamente em seu smartphone, tablet ou computador - sem a necessidade de um dispositivo Kindle.
Leia instantaneamente em seu navegador com o Kindle para internet.
Usando a câmera do seu celular, digitalize o código abaixo e baixe o app Kindle.
OK
Imagem não disponível
Cor:
-
-
-
- Para ver este vídeo faça o download Flash Player
Tidy First? (English Edition) eBook Kindle
Tidying up messy software is a must. And that means breaking up the code to make it more readable, and using guard clauses and helping functions to make it understandable. In this practical guide, author Kent Beck, creator of Extreme Programming and pioneer of software patterns, suggests when and where you might apply tidyings in your code.
Instead of trying to master tidying all at once, this book lets you try out a few examples that make sense for your problem. If you have a big function containing many lines of code, you'll learn how to logically divide it into smaller chunks. Along the way, you'll learn the theory behind software design: coupling, cohesion, discounted cash flows, and optionality.
- IdiomaInglês
- EditoraO'Reilly Media
- Data da publicação17 outubro 2023
- Tamanho do arquivo2778 KB
- The biggest cost of code is the cost of reading and understanding it, not the cost of writing it.192 leitores do Kindle destacaram isso
- Tidyings are a subset of refactorings. Tidyings are the cute, fuzzy little refactorings that nobody could possibly hate on.156 leitores do Kindle destacaram isso
- Reorder the code in the file in the order in which a reader (remember, there are many readers for each writer) would prefer to encounter it.152 leitores do Kindle destacaram isso
Descrição do produto
Sobre o Autor
Readers can connect with or follow him via:
Facebook: https: //www.facebook.com/kentlbeck
Twitter: https: //twitter.com/KentBeck
LinkedIn: https: //www.linkedin.com/in/kentbeck
Medium: https: //medium.com/@kentbeck_7670
Website: https: //www.kentbeck.com
Detalhes do produto
- ASIN : B0CL7ZMLWH
- Editora : O'Reilly Media; 1ª edição (17 outubro 2023)
- Idioma : Inglês
- Tamanho do arquivo : 2778 KB
- Quantidade de dispositivos em que é possível ler este eBook ao mesmo tempo : Ilimitado
- Leitura de texto : Habilitado
- Leitor de tela : Compatível
- Configuração de fonte : Habilitado
- X-Ray : Não habilitado
- Dicas de vocabulário : Habilitado
- Número de páginas : 142 páginas
- Ranking dos mais vendidos: Nº 23,401 em Loja Kindle (Conheça o Top 100 na categoria Loja Kindle)
- Avaliações dos clientes:
Sobre o autor
Descubra mais livros do autor, veja autores semelhantes, leia blogs de autores e muito mais
Avaliações de clientes
As avaliações de clientes, incluindo as avaliações do produto por estrelas, ajudam os clientes a saberem mais sobre o produto e a decidirem se é o produto certo para eles.
Para calcular a classificação geral por estrelas e o detalhamento percentual por estrelas, não usamos uma média simples. Em vez disso, nosso sistema considera coisas como o quão recente é uma avaliação e se o avaliador comprou o produto na Amazon. As avaliações também são analisadas para verificar a confiabilidade.
Saiba mais sobre como as avaliações de clientes funcionam na Amazon-
Melhores avaliações
Principal avaliação do Brasil
Ocorreu um problema para filtrar as avaliações agora. Tente novamente mais tarde.
I love the way Kent Beck always describes complex topics with the perfect examples in a direct and objective way.
This style of writing makes his books easy and fast reading.
This is the first part of a series of books about software design. I will be anxiously waiting for the next.
Principais avaliações de outros países
The problem with traditional refactoring comes into play when there are other people waiting for the work you're doing. There's pressure from product and engineering leadership to get something shipped. Refactors aren't necessary to those stakeholders and so it just ends up in a backlog of technical debt to be solved when that part of the code breaks in production, probably as a rushed hotfix.
Tidy First has made me realize that it's ok to just do a little cleanup around the changes I'm making. Keep it small, and don't change the behavior. As I was reading through this book, in a single sitting, I realized that I already do many of the tidyings Kent recommends, I just didn't have a proper name for them or consider them as refactors.
Where the true value of this book comes from is in the when and why sections. I now have a framework to apply to the decisions I make to know when it's ok to tidy the code and an understanding of why I should or shouldn't make those changes.
This book belongs on the desks of every software engineer. Refer to it whenever you see code that looks a little messy or is hard to understand.
I look forward to reading the rest of the books in this new series that Kent is releasing!
It was a quiet Thursday afternoon, I was sitting at my desk in the office. Suddenly, but not unexpectedly, a notification arrived - one of the jung devs assigned me to a code review. 30+ changes. Nothing crazy. Business as usual. I was kind of bored, so I decided to do it the old-school way - pair with the dev and ask the dev to guide me through the changes. We were both in the office anyway.
While reviewing we found a couple of things that could be improved, refactored, or deleted. In the beginning, the dev was in an "OK, that's a cool suggestion" mood, but after a while, he said, "Are you sure that this is in the scope of this ticket?". My immediate answer was "What? Do you expect a ticket that says 'please refactor your messy code'?". The dev's answer was "No", and the refactoring began. It wasn't anything large, split the big class into two smaller classes, one for read-only operations and one for everything else, plus a couple of minor facelifts.
While riding home, my brain was raging. This is the root of all software problems. Jung developers think in terms of tickets. They don't refactor their code, because they think that this process should be somehow regulated by the management. They wait and wait and what, applying more and more duck tape changes to the code, and so the mess grows and grows.
After two days of raging and trying to assemble my thoughts into something structural I started to google. There should be something on this topic. I found a couple of Kent Beck's talks on YouTube, the most important being "Tidy First? Kent Beck on Refactoring". Oh my god, this is exactly what I'm thinking about. I've promptly ordered the book. Read the same day it's arrived. 100 pages, with quite a few being blank for better chapter separation. Kent nails it. Everything makes perfect sense. Everything starts with the individual, your relationship with yourself, and your goals.
This is the exact book I need to explain to the devs how to approach refactoring on a small single-contributor scale.
If you're still thinking about it - just do it. It's worth it.