Read e-book Managing Software Debt: Building for Inevitable Change (Agile Software Development Series)

Free download. Book file PDF easily for everyone and every device. You can download and read online Managing Software Debt: Building for Inevitable Change (Agile Software Development Series) file PDF Book only if you are registered here. And also you can download or read online all Book PDF file that related with Managing Software Debt: Building for Inevitable Change (Agile Software Development Series) book. Happy reading Managing Software Debt: Building for Inevitable Change (Agile Software Development Series) Bookeveryone. Download file Free Book PDF Managing Software Debt: Building for Inevitable Change (Agile Software Development Series) at Complete PDF Library. This Book have some digital formats such us :paperbook, ebook, kindle, epub, fb2 and another formats. Here is The CompletePDF Book Library. It's free to register here to get Book file PDF Managing Software Debt: Building for Inevitable Change (Agile Software Development Series) Pocket Guide.

Targetprocess offers one solution to avoid this problem with our visual people allocation tool. Let's examine some options your team has to start increasing speed without decreasing employee satisfaction. Your team should never find themselves in an endless sprint. While sprints are acceptable over short periods of time, running your developers ragged for months is the best way to burn them out.

However, you can't always guarantee that your team will be able to work in "marathon mode" at a slow but steady pace where there's never any stress, and no deadline is urgent. There are many other strategies you can use to increase your speed in software development without making your employees hate you. I'll discuss a handful of those strategies below. If you want to get more work done, your first instinct might be to hire more people to do that work. The thing to keep in mind here is that, while hiring new people will eventually increase your development speed, it'll decrease it in the short term.

Conducting technical interviews takes developers away from important tasks. Plus, once you hire someone, it'll take several months to train and mentor them properly. More people also means more team coordination. If you don't keep coordination activities in check, you'll spend more time in poorly conducted meetings or on activities that don't directly add value. When hiring more people, consider dividing your growing team into smaller semi-autonomous, cross-functional units that can make important decisions and move large chunks of your projects forward.

Dividing teams and responsibilities this way ensures that some part of your development project is always making progress. If hiring en masse isn't in your budget, you can focus on increasing your development team's skill level. Developers operating at a higher skill level solve problems faster and create less complex solutions. This transformation obviously won't happen overnight, but you can start by actively encouraging your team members' continuous learning and skill development. Create a learning library, and encourage book clubs.

Send your developers to conferences. Create internal conferences or conduct employee-led workshops to facilitate knowledge sharing. Dedicate time in your work week exclusively to professional development or personal projects. If you do need skilled hands right now, you might want to consider hiring experienced developers who can complete more complex work in shorter periods of time.

However, hiring not-so-skilled developers isn't necessarily a bad investment for your team as long as they're enthusiastic about learning new things. People who are ridiculously curious are more likely to acquire new skills with less need for external motivation from managers. Investing in your team's skill level will both improve the quality of your final product and increase development speed over time.

Complexity is inevitable in software development, but it's also a considerable speed inhibitor.

  • Browse more videos.
  • Introduction to Mechatronics and Measurement Systems, Fourth Edition.
  • Nagios Core Administration Cookbook.
  • Featured channels.
  • Bariatric Surgery: Technical Variations and Complications;

As a system increases in complexity, it becomes more difficult to add new features, spot and fix bugs, and generally understand what's going on within it. You might partially solve this problem by following tip 2: skilled developers tend to build less complex systems, while novice developers tend to create fragile, overcomplicated solutions. However, when attempting to decrease complexity, there are a couple of other factors you should be wary of or avoid entirely.

Technical debt is a deliberate decision to implement not-the-best solution or write not-the-best code to release software faster. Taking on some technical debt is inevitable and can increase speed in software development in the short run. However, in the long run, it contributes to system complexity, which slows you down. Taking on some technical debt increases development speed, but only in the short term.

Never take on technical debt "just because. However, rushing without reason can result in shoddy code that's full of bugs. Plus, your developers won't be happy with unreasonable deadlines. When you do decide to take on technical debt, have a plan to reduce it via refactoring or a full rewrite.

Schedule "maintenance days" periodically so your technical debt doesn't grow out of control. Cowboy coders ignore the development process without regard for how their actions impact their team or the quality of the final product. These coders can create subpar code by cutting corners and trying to move forward as quickly as possible.

Over time, this type of attitude can lead to more complexity. I'm confident that it isn't consistently the 3rd time, yet that isn't the element of this assertion in any respect. This will get us to our subsequent precept of Executable layout: layout and build for switch instead of toughness.

Duplication creates many of the upkeep complications for getting older software program and checks. Maintainability of try scripts is reliant on persevered removing of duplication, together with utilization of try information throughout a number of scripts. Use references from the present try case to different scripts that comprise the attempt facts used.

What's more, she will share the most common dos and don'ts that you can follow when creating your own job descriptions and offers. She will also embellish your journey with invaluable and true war stories that she actually experienced during the past twenty years. If you still manage to be hungry after this reading, you will find plenty of excellent references to other books whose content nicely complements Johanna's masterpiece. This pages book enclosing a mountain of priceless information is definitely one of the best books on hiring management available on the market today.

Practical Subversion by Garrett Rooney. Apress 1 edition November pages. It takes the reader from creating his first repository, importing his first project, checking out a working copy, and so on, to administering the repository and integrating with it using a number of programming languages -- briefly but still. Having said that, and even though it certainly covers a lot of ground, "Practical Subversion" is not a complete reference. The author covers all subjects in a pragmatic manner, covering the common needs well and giving enough hints to help the reader in finding answers for the edge cases.

What I especially like about product-oriented books like this one is when the authors sneak in advice on best practices in using the product, the "tips and tricks" type of gems that make you go "wow" in a bathtub. In addition to learning how to take a backup, I now know how to add auto-completion for Subversion commands in Bash! This book is different. It sets out to offer the advice of someone who has been running software projects with over hundred people using an agile process -- to help others succeed in the same.

While there aren't any hard numbers and the like, a formula to make a silver bullet, there's plenty of sound advice starting from structures to help scale up an agile process, the challenges one will encounter while scaling, and the peopleware issues evident in large, often distributed projects as well as large companies in general, with all the associated bureaucracy and policies.

The discussions about building teams around features versus components, for example, and the division into domain teams and technical service teams are useful reading for someone facing such decisions. Also, this book does not expect you to know the slang of agile software development. It's written so that a manager familiar with software development -- but not necessarily agile software development -- has no problem understanding what the author is trying to pass on.

What's missing from this book -- something one might wish to get support for, facing a larger than usual agile project -- is the deeper coverage of techniques to facilitate things like emergent architecture across a distributed development team. The project report from a member software project was not quite as detailed as I would've hoped.

Detailed case studies are something I am personally very interested in reading. In summary, while the advice in this book is relatively abstract, and you might think it doesn't have that much to offer if you are already familiar with Agile Software Development in general, I would certainly not dare to risk a large project by NOT reading this book. Addison-Wesley Professional second edition November pages. After 5 years, the 2nd edition faces a much different world but also with much different content and approach.

The world has learned much and so has the author. I'm glad to see that this 2nd edition reflects that development. Beck has revised his thinking throughout the book. Some obvious examples include his current preference towards using ideal time over abstract time units in estimating, the fifth value among the initial four, the new set of principles, and the rehash of the practices. Extreme Programming Explained is not a detailed how-to for adopting the process it describes. Actually, it doesn't really describe a process at all. What it does describe is a system of values and principles and a set of practices to support these.

Even though Beck does give each practice divided into primary and corollary practices in the 2nd edition their share of explanation, the focus is still strongly on the "what" and "why" instead of the "how". As someone who has read a dozen books on the topic already, I was delighted to find almost every page to provide something intriguing that either created or challenged my own thoughts.

Especially the latter half of the book, dealing with topics such as TOC, scaling, Taylorism, the Toyota Production System, and hot potato itself, offshoring, offered a lot to think about. This is what a 2nd edition should be like, every single chapter reflecting new insight gathered over the years. Subversion in Action by Jeffrey Machols.

Manning Publications 1 edition December pages. Branching, tagging releases, merging changes, etc. If you're one of those people like me and you happen to be using Subversion, this book should be high up on your shopping list. Jeffrey Machols does a great job in explaining the fundamental concepts of version control and has injected plenty of tips for how to accommodate configuration management in a software development process.

That's something many tool-oriented books have lacked, in my experience. In addition to that, Machols gives the most thorough walkthrough of Subversion tools and features I've seen. File permissions, repository-wide revisions, client commands, administrating the repository, taking backups, setting up authentication, configuring the standalone server process as well as the Apache module, wiring up commit hooks.

There's very few things missing from this book and the topics that are covered are covered well! After reading it, I have to say it does so very well. Instead, it looks at agile project management as a whole and offers insights to various aspects of it through the words of a number of well-known authors all of whom have donated any author royalties from this book to charity!

While the book has been stitched together from a huge cast of authors, the whole really is a well balanced whole although some chapters do stick out from the rest, being rather academic for my taste. The book really is a one-stop shop for describing agile software development to a project manager. It doesn't just run through the usual stuff found in pretty much any book on agile software development but also discusses hot potatoes like fixed-price contracts and documentation.

I've read a whole bunch of books on agile software development and I still found plenty of material in this book that made my eyes gleam of new insight. I'm rating this one at no less than 9 horseshoes! Ship It! Pragmatic Bookshelf 1 edition June pages. If you've ever worked on a troubled project, you know what it feels like. The frustration. The sense of impending doom. The urge to polish your resume. We've all been there. So have Richardson and Gwaltney -- and they're offering to leverage their considerable experience to help save you and your project.

There's not much material that's truly new between these covers, but the presentation and point of view is refreshing.

PDF Download Managing Software Debt: Building for Inevitable Change (paperback) (Agile Software

It's a rare book that speaks convincingly to both developers and managers, but this one does. The book describes many of the practices of agile development -- continuous integration, automated testing, lightweight planning -- and combines them into a simple, powerful approach to building software called "Tracer Bullet Development. My favorite part of the book is compendium of one-page essays on common problems software projects have, and how to apply the principles and practices from the book to solve them.

Unlike some other rather strained "antipatterns" catalogs that I've read, this section feels very practical and usable. If your shop has trouble shipping quality software on time -- and let's face it, most do -- then this book is for you. If you're a manager, I'd say that doubly so. The development of such systems usually involves people from several sectors, such as the IT sector as the solution provider and the business sectors for which the software solution is being devised. Since the needs are usually expressed by the customer, it becomes immediately clear that one of the most critical phases of the software development lifecycle is the requirements phase.

Failing to efficiently manage that phase can have disastrous consequences as the implemented solution might not correctly fulfill the customer's needs. Alan M. Davis, an award-winning professor, author and entrepreneur, contributes very useful requirements management techniques for effectively performing and managing requirements elicitation, triage, specification and change.

Davis argues that one of the main points to focus on when managing requirements is to allow computer-savvy IT actors and computer agnostic business actors to understand each other by using a language that can be understood by both parties and that can be easily adapted to the relative complexity of the problem and to the available resources.

If you repeatedly find yourself having troubles managing requirements for your information system development projects, or if you have a hard time communicating with your marketing or business departments or even with your customers, this book will undoubtedly make your day. If successfully applied, Davis' techniques will definitely have a highly positive impact on both your budgets and the quality of the delivered solutions. Nagel writes this book for both of these audiences in a plain, easy to read style.

As expected, the book covers the basic concepts of VC software, offers comparisons between Subversion and several other VC systems, and discusses Subversion's command set in detail. But the most valuable part of the book are the numerous discussions throughout of practical approaches to working in a VC environment and to managing a Subversion repository. There's some great material on how VC practices and development methodologies affect each other, and there are some detailed case studies of individual companies and how they use Subversion -- right down to the details of the client software, repository layout, and automation scripts that they use.

There's always a danger that a book documenting a specific software package will simply duplicate material that's already in the manual; that really doesn't happen here. Prospective Subversion users -- whether they're coming from a CVS or SourceSafe environment, or if they're new to VC all together -- won't go wrong with this book. Five Core Metrics by Lawrence H. Putnam, Ware Myers.

Without proper tooling, this failure to adequately calculate the duration of a project is not only unavoidable but it usually has dramatic effects on the project outcome. By gathering basic facts from more than 6, past projects, the authors have managed to factor out five key metrics, such as, development time, work effort, number of functionalities, defect rate and process productivity, which they then correlate in a couple of mathematical equations that uniquely define any kind of software development project.

These equations provide a unique and powerful scientific means for correctly gauging the different metrics at hand and for successfully fine-tuning the software management process. If you want to stop wondering whether you'll deliver your project five or six month too late and to start capitalizing on the knowledge from past projects, let this book show you the path. Be advised that this is not an academic book as the whole content is built around concrete data gathered by seasoned professionals from real-world settings.

Apress 1 edition September pages. How many times have you successfully managed to identify the key factors that made these projects derail? Have you noticed anything wrong at all? Have you asked yourself why software development projects are so difficult to manage and so hard to bring to successful completion? To answer these questions, Stepanek first enumerates twelve fundamental facts software is complex, change is inevitable, etc.

Secondly, the author lists ten wrong assumptions scope can be completely defined, all developers are equivalent, etc. Building on this, Stepanek analyzes three modern project management methodologies Crystal, XP and RUP and shows how they can be used for solving some of the identified issues as well as how they fail to address some of the problems.

To cope with this, Stepanek delivers seven techniques to help you finish your projects on time and on budget. Finally, the author introduces a case study made up of real facts that demonstrates how things can usually go bad and how to make them go well. If you have already found yourself helpless when answering any of the above questions, this book will definitely provide you with clear and definite answers as well as a couple useful techniques. Armed with that knowledge and your past experience, you will become a successful and highly respected project manager.

Unit Test Frameworks by Paul Hamill. O'Reilly unknown edition October pages. So why did I decide to read this book? I read this book because I thought that might help me venture a bit outside my familiar JUnit turf and into doing test-first programming with languages other than Java. The short version? A very nice introduction to all the included xUnit ports. The long version? Read on. The first four chapters are general introduction to the topic of unit testing and to some degree, test-driven development. I was prepared to do a quick scan through them all but ended up reading chapters 3 xUnit architecture and 4 writing unit tests almost word to word -- the topic was mostly familiar but the authors solid writing kind of kept me going.

The first two chapters didn't pique my interest that much, perhaps because I had already seen people develop a unit test framework from scratch as an introduction to the domain. The real meat of the book that I was looking forward to was in chapters 7 through 9, the introductions to CppUnit, NUnit, PyUnit -- which were mostly new to me although I had done very little fooling around with them before.

I wasn't disappointed.

Our Agile Disciplines — Europe

The author managed to put together a pretty good set of tutorials for these frameworks. Obviously the same information is available online but I still prefer reading a treekiller rather than a printout of a web page. Not that they were in anyway badly written. I just felt like they didn't belong. I would've personally swapped in a couple of additional xUnit ports instead Ruby and PHP, for example.

This is definitely not a book you'll carry with you from project to project. There's approximately pages of substance split among half a dozen topics so none of them gets covered in detail. The rest, almost pages of the book is what I'd classify as "nice to have" -- I don't mind having that material in the book but I also wouldn't have minded if they'd left them out. However, you might be disappointed if you're looking for a more long-lasting companion.

I read the beta drafts of the book like many others at the time and was instantly gratified as I read through the table of contents. Ward and Rick didn't make the mistake of writing a pure tool book. They wrote a book that focuses not just on the tool itself but also on using the tool. I ordered a hardcopy as soon as it was released. I devoured it, loved it, and am still using it as a reference today on projects using Fit. The first part is all about expressing tests with Fit's tables in a way that communicates well. The built-in fixtures are introduced one by one from the perspective of a test engineer wanting to test different kinds of aspects of a system.

The first time the authors actually show how to run the tests is in chapter 7. This approached proved to be an excellent choice, as far as I'm concerned. The focus really stays on creating tests without digressions into technical implementation. After a brief tour through FitNesse, a display of Fitlibrary's power and flexibility, and some miscellaneous topics, Part 2 takes the reader to another level -- the process of turning requirements into Fit tables and the strenghts and benefits of using a tool like Fit in developing software.

This is delivered using an imaginary software project as a vehicle in illustrating the communication between people while they're honing their acceptance tests. Part 3 turns the table and puts the developer hat on. In an action-packed 70 pages, the authors show how to write the Java code backing up all those different kinds of fixture tables we saw in Parts 1 and 2.

The discussion is concise and to the point, covering the fixtures rather well. Having said that, I was left with some open questions regarding extending the built-in and Fitlibrary fixtures, mostly regarding Fit's internal API. That, however, has been a problem with me and Fit since day one so it's probably just my wiring that's incompatible.

Besides, there's more on the internals in the last part of the book. Part 4 is two-fold. First, we see how the fixtures created in Part 2 look like in Java. There's not too much explanation involved but I didn't feel like that was an issue.


The rest of Part 4 is a mixture of topics such as mocking certain aspects of a system, making the system's architecture more testing-friendly, and such. I have to say I was a bit disappointed by the mocking section, having hoped for a more elaborate example rather than sticking to faking system time.

Part 5 starts with a very brief description of Fit's internal API introducing concepts of Parse object, "more", and so forth, if you've already taken a peek at Fit's source code and how to develop custom fixtures. Personally, I would've liked to have a lot more material on this exact topic but even the brief overview helped solidify some of the things I had picked up here and there while reading the Fit source code, trying to figure out how to write custom fixtures.

Trying to summarize all that, I'd claim that "Fit for Developing Software" is a must read for anyone involved in using Fit. It's a tremendous resource, especially considering how little documentation on Fit is available online. The book does have its deficiencies as well, though. Whereas the arguably most important aspect of creating tests is covered extremely well, the poor fixture developer still has to figure out a lot of stuff out on her own as the custom development topic is not covered as thoroughly.

Still, a great book and a warm recommendation from me. In the programming world, this title Architect is defined in many different ways, some that are too low level that they are really just designers, and not architects, in the traditional sense of the word. An Architect not only looks at technologies and decides which will work best for their project, but they must also define process and standards. They must understand about human behavior, build teams, and learn to learn quickly.

But most think an architect just draws UML collaboration diagrams. This is the first time I have read a book on being an architect that surpassed my definitions of what an architect is. I want to be an architect and this book has taught me much more than I could have thought of.

There are a few rare breed of books that are the top of its class, this book is one of them. If you dream of becoming an Architect then you must buy this book. O'Reilly 1 edition August pages. There is not chance of that because you never forget your book on Business Process Modeling, not because it blows you away, but because of how many naps you take while reading it. The subject is very boring, not for your everyday programmer. But there is a need, and to be honest, even though I was bored, I know that this was a very good book explaining the technologies that are out there, the BPM Design Patterns, The "languages" and some examples using them, and a good amount of diagrams showing "workflow".

So, if you are one of the lucky few who either love BPM or just have a job at Filenet, then this is a great book for you to pick up. Pragmatic Bookshelf 1 edition September pages. In the book, the authors describe how a manager can help her team achieve great things by doing the little things well. The book follows the manager, Sam, of an imaginary IT department in his day to day actions with which he helps his direct reports overcome -- and sometimes learn about -- issues they're facing in their teams and the organization.

These day-to-day actions are a mixture of techniques for handling difficult conversations, facilitating effective meetings, coaching your coworkers, and generally working with and for the people you are managing. I thoroughly enjoyed reading the book and, even though I'm currently working as a consultant, have already been able to apply some of the techniques at work. For an acting manager, I'd say this book is a must read. Now if only it'd fit in a back pocket IBM Press 1 edition November pages.

If you're looking for an in-depth technical overview of SOA and a guide showing you how to build services in a specific technology, this book isn't for you. What this book does do is present SOA from many different perspectives, the first of which is all about the business value of SOA and how it facilitates agility within an enterprise. It also reinforces the fact that, particularly in an SOA world, IT really does need to work as closely with the business as possible, taking their lead to ensure that IT can change with the business.

Following on from this is a look at some of the architectural characteristics of SOA, before moving on to explain how you might plan an SOA project and define people's roles. It then goes on to provide guidance of how to perform the analysis and design activities associated with building an SOA. I really like this and have subsequently adopted it my current project. As a technical architect, I found "Determining Non-Functional Requirements" and "Security" extremely relevant to my current role, with the latter chapter providing lots of really pragmatic advice about end-to-end security within an SOA.

This is great, and it's rare to find a book that says, "you might not actually need all the overhead of this ideal solution, so here's a much simpler alternative and it's okay to use it". Wrapping up the book are chapters on management and a couple of case studies, one of which resembles our own SOA.

Personally, while I found the initial chapters on business value interesting, I got most value out of the latter half of the book purely because it's just very relevant to the work that I'm doing at the moment. This book manages to distill an obvious amount of SOA experience across many projects into a few hundred pages and, at every stage, I was left with a warm feeling that many of the decisions we've made on our project match up with the best practices being recommended here.

My only criticisms are that the style is a little heavy going in places and there are unsurprisingly quite a lot of references to IBM products, especially in the management chapter towards the end. Overall, if you're an architect looking at SOA now or planning to in the future, this book will help you clarify your thoughts and steer you through the brave new world of a service oriented architecture. It comes highly recommended. Pragmatic Bookshelf 1 edition April pages.

Methodologies, tools, and even programming languages have had the adjective applied to them. But what does it mean to be an "agile developer"? How do we know if we're "agile"? Should I expect the ladies to saunter over at parties and say, "I couldn't help noticing that you're agile, how about coming back to my place"? To answer these questions, a good place to start would be to read "Practices of an Agile Developer".

This book, which could have easily been titled "Forty-five Habits of Highly Agile People", starts out by defining agility and what it means for something to be agile. Your companions on your journey are a demon whose taunts remind you of how not to do things, and a guardian angel eager to steer you onto the path of righteous agility.

Each practice is well motivated and adequately described. Additionally, each has sections letting you know what it should feel like if you are following the practice correctly, and how to strike a balance to keep from going overboard or not far enough when following a particular practice. While the focus of this book is agility, the practices described really lend themselves well to all developers, even the agility impaired. Practices such as "Question until you understand" and "Write cohesive code", to name only a couple, are just plain old good advice for anyone who writes code.

Related Posts

So even if you don't aspire to reach the summits of agility, you can look at this book as a self-help book for developers. Read it, soak in some of the good sense it offers, and be better for it. IBM Press 1 edition June pages. It is useful if you are doing exactly what the book discusses. In particular, you should be using all three of these technologies and want to do standard builds. The concepts were excellent. There was a strong emphasis on understanding the terminology.

For examples, configuration management and build terms were clearly discussed. The roles involved were also described. He calls these "best practices. Due to this approach, the book doesn't offer much instruction on customization. The coverage of ClearCase was very thorough. This book will save you a lot of time in getting an automated build working if you haven't used the technologies before. It supplements the materials available on the web nicely.

O'Reilly 1 edition November pages. While the real title of this book is "Time Management for System Administrators," it is really useful for any techie who faces interruptions. And that's most of us! In the preface, the author states: "This book is not for programmers. Beta readers told me that programmers should find this book extremely useful, but We support production applications, have emergency issues and are frequently called on to answer tech questions.

The book introduces readers to traditional time management concepts in case they are unfamiliar with them. Then the author adapts those techniques to work well when your priorities change throughout the day. There are also chapters are reducing stress, e-mail management and automation. I found the techniques on prioritizing to be much more relevant than the typical time management book. Since the book is not teaching a technology, it was easier to read than the typical white book with an animal on the cover. The quality is high as you would expect. I read this page book in four days.

It was hard to put down! How much would you pay to have a better handle on your time and responsibilities? Joel on Software by Joel Spolsky. Since there were enough "other things" to interfere with reading, I give the book a 7. What I liked: 1 There were many good points throughout the book. What I didn't like: 1 There were tons of footnotes with long links, but I can't find the links on joelonsoftware. Does that mean I am supposed to type them in? For example, one starts with the fact that the website was down last Friday. This gives me the feeling that a bunch of blog entries were thrown together with little editing.

NET in This feels very dated now since. NET has since been released. While this is rampant on his blog, I feel that a book should have less advertising. If you like reading Joel's blog, you will probably enjoy the book. However, if you like reading Joel's blog, you've already read much of this. My expectations exceed the actual book. Dennis Gibbs. IBM Press 1 edition August pages. It deepened my understanding of the Unified Process and I think that's really what the book was meant for: to enhance what you already know about the UP. The content is less story-centric than "Lessons from the Trenches" implies, but the short stories included do a decent job of adding some color and flavor.

The book covers a far greater scope of projects than what concerns a typical project manager. Not that the extra information isn't interesting or valuable, but someone expecting a guide of how to be a project manager may be a bit overwhelmed. The title also does not warn though the cover mentions it that the book heavily focuses on dealing with projects that are outsourced, even to the point of the entire first chapter to outsourcing.

If you know something about project lifecycles and the UP yet you wish to learn more, this might be a good addition to your library. Addison-Wesley Professional 1 edition September pages. The businesses that thrive strive to uncover the less than obvious needs while resisting the temptation to bloat their products with unnecessary features. Guess what? You won't develop great products by simply throwing a bunch of business analysts together and telling them to change the world. A great product addresses what customers need, so talk to the customers.

Problem there is the customers often don't fully understand their needs, or at least they might not understand how to prioritize their needs. A little guidance is in order. Luke Hohmann's Innovation Games introduces 12 games to play with customers so they will make decisions that reveal "true, hidden needs and desires.

The book segregates itself into two sections. The second part blueprints the dozen games individually and the first part talks about everything surrounding preparations. The author is very thorough in how to prepare, perhaps to help us avoid bad experiences.

I would have been more interested in learning through others' mistakes than through drawn out details on preparatory drudgeries, but that's really the biggest anchor I see on the "Speed Boat". The games are actually pretty good ideas and I hope this book will inspire more like it. If you're like me and want to have Passionate Users, I recommend engaging in Innovation Games - it will help you to better understand your customers' needs. Release It! Pragmatic Bookshelf 1 edition March pages. Working developers quickly learn that the ideal is rarely reality and things happen once we release software out into the wild.

Michael Nygard's "Release It! Nygard talks about all the things that can and will go wrong in the finely crafted software we were sure was ready for production. A full two-thirds of the book is focused on capacity and stability issues including patterns and anti-patterns for both. The remainder of the book deals with general design issues as well as maintaining health and status in an operational system. It's better to learn from the mistakes of others, and I really appreciated the detail Nygard went into addressing some of these horror stories. The Pragmatic Programmers have a few "must read" books and "Release It!

After reading it and heeding its advice, you'll feel a bit better knowing that your software is better prepared for the rigors of production. As such, it reads like a page IBM whitepaper. This isn't inherently good or bad, just important to know. The audience is managers and executives. Each chapter has a "chapter return on investment" where you would normally see an introduction. Note that I'm not in the target audience, so take this review with a grain of salt. The book walks through what to expect at different phases of implementing RUP.

It has good charts and examples -- project plan, charts with sample numbers, org charts, budgets, etc.

  • Books – Agile Crossing.
  • Where Technical Debt Exists;
  • Franklin: The autobiography and other writings on politics, economics, and virtue;
  • Credible Threats in Negotiations: A Game-theoretic Approach.
  • Blog Stats.
  • The Network(ed) Economy: The Nature, Adoption and Diffusion of Communication Standards.

There are examples of common mistakes and things to watch out for. The beginning of the book mentions other process to compare RUP. They walk you through a ranking tool for weighting areas of examination. This happens again in chapter six. While the example is good, I found myself thinking "didn't we already do this? It just felt more like a whitepaper to me than what I'm used to seeing in a book.

Addison-Wesley Professional 1 edition July pages. This series includes books like "Refactoring to Patterns". Each chapter describes CI related practices. There is a chapter dedicated to risks reduced by CI including anti-patterns like "It works on my machine. I particularly like how the authors address the "CI is good by my project is special" problem. The authors give examples in different languages including Java,.

NET and Ruby. The appendices on resources and tools are very useful. The book goes beyond CI and addresses continuous inspection and deployment. My only problem when reading the book is that I forgot I was supposed to be writing a review. It was so good, I just got caught up in the book! Do check out the companion website integratebutton. It currently contains video examples of three practices described in the book. The materials are presented in slide and diagram format. It reinforced the book nicely because it was like a guru explaining his experiences. It also goes into much more detail than the book has room for on each topic.

This is an excellent book and the website adds to it! Implementation Patterns by Kent Beck. The focus is to make us think about writing more readable and maintainable code. Kent Beck accomplishes this by going thru WHY we write things a certain way. The audience is Java developers who know the basics of the language. If you have more experience, you will understand points on a deeper level. If you are newer to Java, you will form good habits. There were just too many things I liked about this book, so here's a list: - clear, concise and short snippets - simple, bare-bones diagrams - discussion on caveats and tradeoffs - over pages of patterns - over 75 patterns - about concepts and OO; not a style guide - focus on values like communication and simplicity - section on cross cutting principles like minimizing repetition - short sections Kent says some chapters long, but 30 patterns in 30 pages has great subdivision - how JUnit 4 design decisions follow theses patterns - Kent even got in a dig about Sun never removing deprecated code - bibliography with a blurb from Kent on each title - pattern index on inside back cover in addition to traditional index The book can be read straight thru or used as a reference.

It's short, light and easy enough that it can be read on an airplane. It's also organized enough to go back and read about the pattern relevant at the time. The book provides tips on the individual, group, team and stakeholder levels. A group is defined as interacting with others without being a team. I particularly liked the inside cover references. These combine to form 16 icons. The icons are used within the chapters to highlight key concepts or find them later.

I also particularly liked the "how is this relevant? After the chapter summary, the author picks key concepts and asks questions to get you thinking about how it applies in your workplace. I'm always a bit sceptical of books that claim to address everyone involved in the software development process including managers, developers and stakeholders. This book manages the task impressively. And finally, the book resonates with problems and phrases used in industry. My favorites are the problem with "and then a miracle happens" and the repeated emphasis on what "done" means throughout the book.

There are good analogies, stories and examples throughout the book. It was a great read and very informative. I highly recommend this book. O'Reilly 1 edition June pages. A collection of 33 chapters, each by a different author, all of them worthy of study and thought.

What is Agile Software Development?