Working Effectively with Legacy Code by Michael Feathers (English) Paperback Boo

Description: Working Effectively with Legacy Code by Michael Feathers This book provides programmers with the ability to cost effectively handlecommon legacy code problems without having to go through the hugelyexpensive task of rewriting all existing code. It describes a series of practicalstrategies that developers can employ to bring their existing softwareapplications under control. The author provides useful ... FORMAT Paperback LANGUAGE English CONDITION Brand New Publisher Description This book provides programmers with the ability to cost effectively handlecommon legacy code problems without having to go through the hugelyexpensive task of rewriting all existing code. It describes a series of practicalstrategies that developers can employ to bring their existing softwareapplications under control. The author provides useful guidance about how touse these strategies when refactoring or making functional changes to codebases. One of the books key points is that it teaches developers to write teststhat can be used to make sure they are not unintentionally changing theapplication as they optimize it. Examples are provided in Java, C++, and Csharp,and the book assumes that the reader has some knowledge of UMLnotation. Strategies using UML and code in C++ and Java primarily whilelanguage independent advice will be delivered in side bars and appendices forlanguage specific users. Back Cover Get more out of your legacy systems: more performance, functionality, reliability, and manageability Is your code easy to change? Can you get nearly instantaneous feedback when you do change it? Do you understand it? If the answer to any of these questions is no, you have legacy code, and it is draining time and money away from your development efforts. In this book, Michael Feathers offers start-to-finish strategies for working more effectively with large, untested legacy code bases. This book draws on material Michael created for his renowned Object Mentor seminars: techniques Michael has used in mentoring to help hundreds of developers, technical managers, and testers bring their legacy systems under control. The topics covered include Understanding the mechanics of software change: adding features, fixing bugs, improving design, optimizing performance Getting legacy code into a test harness Writing tests that protect you against introducing new problems Techniques that can be used with any language or platform--with examples in Java, C++, C, and C# Accurately identifying where code changes need to be made Coping with legacy systems that arent object-oriented Handling applications that dont seem to have any structure This book also includes a catalog of twenty-four dependency-breaking techniques that help you work with program elements in isolation and make safer changes. Author Biography MICHAEL C. FEATHERS works for Object Mentor, Inc., one of the worlds top providers of mentoring, skill development, knowledge transfer, and leadership services in software development. He currently provides worldwide training and mentoring in Test-Driven Development (TDD), Refactoring, OO Design, Java, C#, C++, and Extreme Programming (XP). Michael is the original author of CppUnit, a C++ port of the JUnit testing framework, and FitCpp, a C++ port of the FIT integrated-testing framework. A member of ACM and IEEE, he has chaired CodeFest at three OOPSLA conferences. © Copyright Pearson Education. All rights reserved. Table of Contents I. THE MECHANICS OF CHANGE. 1. Changing Software. 2. Working with Feedback. 3. Sensing and Separation. 4. The Seam Model. 5. Tools. II. CHANGING SOFTWARE. 6. I Dont Have Much Time and I Have To Change It. 7. It Takes Forever To Make a Change. 8. How Do I Add a Feature? 9. I Cant Get This Class into a Test Harness. 10. I Cant Run This Method into a Test Harness. 11. I Need to Make a Change. What Methods Should I Test? 12. I Need to Make Many Changes In One Area Do I Have To Break. 13. I Need To Make a Change but I Dont Know What Tests To Write. 14. Dependencies on Libraries Are Killing Me. 15. My Application Is All API Calls. 16. I Dont Understand the Code Well Enough To Change It. 17. My Application Has No Structure. 18. My Test Code Is in the Way. 19. My Project Is Not Object-Oriented. How Do I Make Safe Changes? 20. This Class Is Too Big and I Dont Want It to Get Any Bigger. 21. Im Changing The Same Code All Over the Place. 22. I Need To Change a Monster Method and I Cant Write Tests for It. 23. How Do I Know That Im Not Breaking Anything? 24. We Feel Overwhelmed. It Isnt Going To Get Any Better. III. DEPENDENCY BREAKING TECHNIQUES. 25. Dependency Breaking Techniques. Appendix: Refactoring. Glossary. Long Description This book provides programmers with the ability to cost effectively handlecommon legacy code problems without having to go through the hugelyexpensive task of rewriting all existing code. It describes a series of practicalstrategies that developers can employ to bring their existing softwareapplications under control. The author provides useful guidance about how touse these strategies when refactoring or making functional changes to codebases. One of the books key points is that it teaches developers to write teststhat can be used to make sure they are not unintentionally changing theapplication as they optimize it. Examples are provided in Java, C++, and Csharp,and the book assumes that the reader has some knowledge of UMLnotation. Strategies using UML and code in C++ and Java primarily whilelanguage independent advice will be delivered in side bars and appendices forlanguage specific users. Feature Proven strategies for maintaining and optimizing legacycode to get the most out of your existing applications. Examples in C-sharp, C++, and Java, as well as strategies for better using theindustry standard modeling language: UML 2.0 Addresses the very concrete problems that programmers face working in the contextof large untested code bases Based on successful classes for Object Mentor, the author helps organizationsmaintain older systems rather than go to the cost of developing new ones Description for Sales People This book provides programmers with the ability to cost effectively handlecommon legacy code problems without having to go through the hugelyexpensive task of rewriting all existing code. It describes a series of practicalstrategies that developers can employ to bring their existing softwareapplications under control. The author provides useful guidance about how touse these strategies when refactoring or making functional changes to codebases. One of the books key points is that it teaches developers to write teststhat can be used to make sure they are not unintentionally changing theapplication as they optimize it. Examples are provided in Java, C++, and Csharp,and the book assumes that the reader has some knowledge of UMLnotation. Strategies using UML and code in C++ and Java primarily whilelanguage independent advice will be delivered in side bars and appendices forlanguage specific users. Introduction or Preface Preface Do you remember the first program you wrote? I remember mine. It was a little graphics program I wrote on an early PC. I started programming later than most of my friends. Sure, Id seen computers when I was a kid. I remember being really impressed by a minicomputer I once saw in an office, but for years I never had a chance to even sit at a computer. Later, when I was a teenager, some friends of mine bought a couple of the first TRS-80s. I was interested, but I was actually a bit apprehensive, too. I knew that if I started to play with computers, Id get sucked into it. It just looked too cool. I dont know why I knew myself so well, but I held back. Later, in college, a roommate of mine had a computer, and I bought a C compiler so that I could teach myself programming. Then it began. I stayed up night after night trying things out, poring through the source code of the emacs editor that came with the compiler. It was addictive, it was challenging, and I loved it. I hope youve had experiences like thismdjust the raw joy of making things work on a computer. Nearly every programmer I ask has. That joy is part of what got us into this work, but where is it day to day? A few years ago, I gave my friend Erik Meade a call after Id finished work one night. I knew that Erik had just started a consulting gig with a new team, so I asked him, "How are they doing?" He said, "Theyre writing legacy code, man." That was one of the few times in my life when I was sucker-punched by a coworkers statement. I felt it right in my gut. Erik had given words to the precise feeling that I often get when I visit teams for the first time. They are trying very hard, but at the end of the day, because of schedule pressure, the weight of history, or a lack of any better code to compare their efforts to, many people are writing legacy code. What is legacy code? Ive used the term without defining it. Lets look at the strict definition: Legacy code is code that weve gotten from someone else. Maybe our company acquired code from another company; maybe people on the original team moved on to other projects. Legacy code is somebody elses code. But in programmer-speak, the term means much more than that. The term legacy code has taken on more shades of meaning and more weight over time. What do you think about when you hear the term legacy code ? If you are at all like me, you think of tangled, unintelligible structure, code that you have to change but dont really understand. You think of sleepless nights trying to add in features that should be easy to add, and you think of demoralization, the sense that everyone on the team is so sick of a code base that it seems beyond care, the sort of code that you just wish would die. Part of you feels bad for even thinking about making it better. It seems unworthy of your efforts. That definition of legacy code has nothing to do with who wrote it. Code can degrade in many ways, and many of them have nothing to do with whether the code came from another team. In the industry, legacy code is often used as a slang term for difficult-to-change code that we dont understand. But over years of working with teams, helping them get past serious code problems, Ive arrived at a different definition. To me, legacy code is simply code without tests. Ive gotten some grief for this definition. What do tests have to do with whether code is bad? To me, the answer is straightforward, and it is a point that I elaborate throughout the book: Code without tests is bad code. It doesnt matter how well written it is; it doesnt matter how pretty or object-oriented or well-encapsulated it is. With tests, we can change the behavior of our code quickly and verifiably. Without them, we really dont know if our code is getting better or worse. You might think that this is severe. What about clean code? If a code base is very clean and well structured, isnt that enough? Well, make no mistake. I love clean code. I love it more than most people I know, but while clean code is good, its not enough. Teams take serious chances when they try to make large changes without tests. It is like doing aerial gymnastics without a net. It requires incredible skill and a clear understanding of what can happen at every step. Knowing precisely what will happen if you change a couple of variables is often like knowing whether another gymnast is going to catch your arms after you come out of a somersault. If you are on a team with code that clear, you are in a better position than most programmers. In my work, Ive noticed that teams with that degree of clarity in all of their code are rare. They seem like a statistical anomaly. And, you know what? If they dont have supporting tests, their code changes still appear to be slower than those of teams that do. Yes, teams do get better and start to write clearer code, but it takes a long time for older code to get clearer. In many cases, it will never happen completely. Because of this, I have no problem defining legacy code as code without tests. It is a good working definition, and it points to a solution. Ive been talking about tests quite a bit so far, but this book is not about testing. This book is about being able to confidently make changes in any code base. In the following chapters, I describe techniques that you can use to understand code, get it under test, refactor it, and add features. One thing that you will notice as you read this book is that it is not a book about pretty code. The examples that I use in the book are fabricated because I work under nondisclosure agreements with clients. But in many of the examples, Ive tried to preserve the spirit of code that Ive seen in the field. I wont say that the examples are always representative. There certainly are oases of great code out there, but, frankly, there are also pieces of code that are far worse than anything I can use as an example in this book. Aside from client confidentiality, I simply couldnt put code like that in this book without boring you to tears and burying important points in a morass of detail. As a result, many of the examples are relatively brief. If you look at one of them and think "No, he doesnt understandmdmy methods are much larger than that and much worse," please look at the advice that I am giving at face value and see if it applies, even if the example seems simpler. The techniques here have been tested on substantially large pieces of code. It is just a limitation of the book format that makes examples smaller. In particular, when you see ellipses (el) in a code fragment like this, you can read them as "insert 500 lines of ugly code here": m_pDispatcher->register(listener);...m_nMargins++; If this book is not about pretty code, it is even less about pretty design. Good design should be a goal for all of us, but in legacy code, it is something that we arrive at in discrete steps. In some of the chapters, I describe ways of adding new code to existing code bases and show how to add it with good design principles in mind. You can start to grow areas of very good high-quality code in legacy code bases, but dont be surprised if some of the steps you take to make changes involve making some code slightly uglier. This work is like surgery. We have to make incisions, and we have to move through the guts and suspend some aesthetic judgment. Could this patients major organs and viscera be better than they are? Yes. So do we just forget about his immediate problem, sew him up again, and tell him to eat right and train for a marathon? We could, but what we really need to do is take the patient as he is, fix whats wrong, and move him to a healthier state. He might never become an Olympic athlete, but we cant let "best" be the enemy of "better." Code bases can become healthier and easier to work in. When a patient feels a little better, often that is the time when you can help him make commitments to a healthier life style. That is what we are shooting for with legacy code. We are trying to get to the point at which we are used to ease; we expect it and actively attempt to make code change easier. When we can sustain that sense on a team, design gets better. The techniques I describe are ones that Ive discovered and learned with coworkers and clients over the course of years working with clients to try to establish control over unruly code bases. I got into this legacy code emphasis accidentally. When I first started working with Object Mentor, the bulk of my work involved helping teams with serious problems develop their skills and interactions to the point that they could regularly deliver quality code. We often used Extreme Programming practices to help teams take control of their work, collaborate intensively, and deliver. I often feel that Extreme Programming is less a way to develop software than it is a way to make a well-jelled work team that just happens to deliver great software every two weeks. From the beginning, though, there was a problem. Many of the first XP projects were "greenfield" projects. The clients I was seeing had significantly large code bases, and they were in trouble. They needed some way to get control of their work and start to deliver. Over time, I found that I was doing the same things over and over again with clients. This sense culminated in some work I was doing with a team in the financial industry. Before Id arrived, theyd realized that unit testing was a great thing, but the tests that they were executing were full scenario tests that made multiple trips to a database and exercised large chunks of code. The tests were hard to write, and the team didnt run them very often because they took so long to run. As I sat down with them to break dependencies and get smaller chunks of Details ISBN0131177052 Author Michael Feathers Language English ISBN-10 0131177052 ISBN-13 9780131177055 Media Book Format Paperback DEWEY 005.1 Illustrations Yes Year 2004 Edition 1st Short Title WORKING EFFECTIVELY W/LEGACY C DOI 10.1604/9780131177055 Series Robert C. Martin Series Country of Publication United States Place of Publication Upper Saddle River AU Release Date 2004-10-14 NZ Release Date 2004-10-14 US Release Date 2004-10-14 UK Release Date 2004-10-14 Pages 464 Publisher Pearson Education (US) Publication Date 2004-10-14 Imprint Pearson Audience Tertiary & Higher Education We've got this At The Nile, if you're looking for it, we've got it. With fast shipping, low prices, friendly service and well over a million items - you're bound to find what you want, at a price you'll love! TheNile_Item_ID:161491188;

Price: 101.53 AUD

Location: Melbourne

End Time: 2024-12-22T02:55:56.000Z

Shipping Cost: 13.8 AUD