Sale!

Clean Code A Handbook of Agile Software Craftsmanship 1st edition by Robert Martin 0136083250 9780136083252

Name: Clean Code A Handbook of Agile Software Craftsmanship 1st edition by Robert Martin 0136083250 9780136083252
SKU: EB-15520
Availability: InStock

Original price was: $50.00.Current price is: $35.00.

Authors:Robert C. Martin , Series:IT & Computer [159] , Tags:Computer Engineering; Information Technology , Author sort:Martin, Robert C. , Identifiers:Identifiers:isbn-13:978-0-13-235088-4 , Languages:Languages:eng , Published:Published:Jul 2008 , Publisher:Pearson Education , Comments:Comments:The mission of this series is to improve the state of the art of software craftsmanship. The books in this series are technical, pragmatic, and substantial. The authors are highly experienced craftsmen and professionals dedicated to writing about what actually works in practice, as opposed to what might work in theory. You will read about what the author has done, not what he thinks you should do. If the book is about programming, there will be lots of code. If the book is about managing, there will be lots of case studies from real projects. These are the books that all serious practitioners will have on their bookshelves. These are the books that will be remembered for making a difference and for guiding professionals to become true craftsman.

SKU: EB-15520 Category: eBook PDF Tags: Clean Code, Handbook, Robert Martin

Description

Clean Code A Handbook of Agile Software Craftsmanship 1st edition by Robert Martin- Ebook PDF Instant Download/Delivery. 0136083250, 9780136083252
Full download Clean Code A Handbook of Agile Software Craftsmanship 1st edition after payment

Product details:

ISBN 10: 0136083250
ISBN 13: 9780136083252
Author: Robert C. Martin

Even bad code can function. But if code isn’t clean, it can bring a development organization to its knees. Every year, countless hours and significant resources are lost because of poorly written code. But it doesn’t have to be that way. 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 This book is a must for any developer, software engineer, project manager, team lead, or systems analyst with an interest in producing better code.

Clean Code A Handbook of Agile Software Craftsmanship 1st Table of contents:

Chapter 1: Clean Code

There Will Be Code
Bad Code
The Total Cost of Owning a Mess
Schools of Thought
We Are Authors
The Boy Scout Rule
Prequel and Principles
Conclusion
Bibliography

Chapter 2: Meaningful Names

Introduction
Use Intention-Revealing Names
Avoid Disinformation
Make Meaningful Distinctions
Use Pronounceable Names
Use Searchable Names
Avoid Encodings
Avoid Mental Mapping
Class Names
Method Names
Don’t Be Cute
Pick One Word per Concept
Don’t Pun
Use Solution Domain Names
Use Problem Domain Names
Add Meaningful Context
Don’t Add Gratuitous Context
Final Words

Chapter 3: Functions

Small!
Do One Thing
One Level of Abstraction per Function
Switch Statements
Use Descriptive Names
Function Arguments
Have No Side Effects
Command Query Separation
Prefer Exceptions to Returning Error Codes
Don’t Repeat Yourself
Structured Programming
How Do You Write Functions Like This?
Conclusion
SetupTeardownIncluder
Bibliography

Chapter 4: Comments

Comments Do Not Make Up for Bad Code
Explain Yourself in Code
Good Comments
Bad Comments
Bibliography

Chapter 5: Formatting

The Purpose of Formatting
Vertical Formatting
Horizontal Formatting
Team Rules
Uncle Bob’s Formatting Rules

Chapter 6: Objects and Data Structures

Data Abstraction
Data/Object Anti-Symmetry
The Law of Demeter
Data Transfer Objects
Conclusion
Bibliography

Chapter 7: Error Handling

Use Exceptions Rather Than Return Codes
Write Your Try-Catch-Finally Statement First
Use Unchecked Exceptions
Provide Context with Exceptions
Define Exception Classes in Terms of a Caller’s Needs
Define the Normal Flow
Don’t Return Null
Don’t Pass Null
Conclusion
Bibliography

Chapter 8: Boundaries

Using Third-Party Code
Exploring and Learning Boundaries
Learning log4j
Learning Tests Are Better Than Free
Using Code That Does Not Yet Exist
Clean Boundaries
Bibliography

Chapter 9: Unit Tests

The Three Laws of TDD
Keeping Tests Clean
Clean Tests
One Assert per Test
F.I.R.S.T.
Conclusion
Bibliography

Chapter 10: Classes

Class Organization
Classes Should Be Small!
Organizing for Change
Bibliography

Chapter 11: Systems

How Would You Build a City?
Separate Constructing a System from Using It
Scaling Up
Java Proxies
Pure Java AOP Frameworks
AspectJ Aspects
Test Drive the System Architecture
Optimize Decision Making
Use Standards Wisely, When They Add Demonstrable Value
Systems Need Domain-Specific Languages
Conclusion
Bibliography

Chapter 12: Emergence

Getting Clean via Emergent Design
Simple Design Rule 1: Runs All the Tests
Simple Design Rules 2–4: Refactoring
- No Duplication
- Expressive
- Minimal Classes and Methods
Conclusion
Bibliography

Chapter 13: Concurrency

Why Concurrency?
Challenges
Concurrency Defense Principles
Know Your Library
Know Your Execution Models
Beware Dependencies Between Synchronized Methods
Keep Synchronized Sections Small
Writing Correct Shut-Down Code Is Hard
Testing Threaded Code
Conclusion
Bibliography

Chapter 14: Successive Refinement

Args Implementation
Args: The Rough Draft
String Arguments
Conclusion

Chapter 15: JUnit Internals

The JUnit Framework
Conclusion

Chapter 16: Refactoring SerialDate

First, Make It Work
Then Make It Right
Conclusion
Bibliography

Chapter 17: Smells and Heuristics

Comments
Environment
Functions
General
Java
Names
Tests
Conclusion
Bibliography

Appendix A: Concurrency II

Client/Server Example
Possible Paths of Execution
Knowing Your Library
Dependencies Between Methods Can Break Concurrent Code
Increasing Throughput
Deadlock
Testing Multithreaded Code
Tool Support for Testing Thread-Based Code
Conclusion

People also search for Clean Code A Handbook of Agile Software Craftsmanship 1st :

clean code a handbook of agile software craftsmanship reddit

clean code a handbook of agile software craftsmanship summary

clean code a handbook of agile software craftsmanship review

clean code rules