Your email was sent successfully. Check your inbox.

An error occurred while sending the email. Please try again.

Proceed reservation?

Export
Filter
  • MPI Ethno. Forsch.  (6)
  • HBZ
  • Beck, Kent  (6)
  • Boston, MA :Safari,  (6)
  • London : Routledge
Datasource
  • MPI Ethno. Forsch.  (6)
  • HBZ
Material
Language
Years
Author, Corporation
Publisher
Keywords
  • 1
    Online Resource
    Online Resource
    Extreme programming explained : embrace change (2004)
    Boston, MA : Addison-Wesley | Boston, MA :Safari,
    Details
    Language: English
    Pages: xxii, 189 p. , ill. ; , 24 cm
    Edition: 2nd ed.
    Keywords: Computer software ; Development ; eXtreme programming ; Electronic books ; local
    Abstract: "In this second edition of Extreme Programming Explained, Kent Beck organizes and presents five years' worth of experiences, growth, and change revolving around XP. If you are seriously interested in understanding how you and your team can start down the path of improvement with XP, you must read this book." - Francesco Cirillo, Chief Executive Officer, XPLabs S.R.L. "The first edition of this book told us what XP was-it changed the way many of us think about software development. This second edition takes it farther and gives us a lot more of the 'why' of XP, the motivations and the principles behind the practices. This is great stuff. Armed with the 'what' and the 'why,' we can now all set out to confidently work on the 'how': how to run our projects better, and how to get agile techniques adopted in our organizations." - Dave Thomas, The Pragmatic Programmers LLC "This book is dynamite! It was revolutionary when it first appeared a few years ago, and this new edition is equally profound. For those who insist on cookbook checklists, there's an excellent chapter on 'primary practices,' but I urge you to begin by truly contemplating the meaning of the opening sentence in the first chapter of Kent Beck's book: 'XP is about social change.' You should do whatever it takes to ensure that every IT professional and every IT manager-all the way up to the CIO-has a copy of Extreme Programming Explained on his or her desk." - Ed Yourdon, author and consultant "XP is a powerful set of concepts for simplifying the process of software design, development, and testing. It is about minimalism and incrementalism, which are especially useful principles when tackling complex problems that require a balance of creativity and discipline." - Michael A. Cusumano, Professor, MIT Sloan School of Management, and author of The Business of Software " Extreme Programming Explained is the work of a talented and passionate craftsman. Kent Beck has brought together a compelling collection of ideas about programming and management that deserves your full attention. My only beef is that our profession has gotten to a point where such common-sense ideas are labeled 'extreme.'..." - Lou Mazzucchelli, Fellow, Cutter Business Technology Council "If your organization is ready for a change in the way it develops software, there's the slow incremental approach, fixing things one by one, or the fast track, jumping feet first into Extreme Programming. Do not be frightened by th...
    Note: Includes bibliographical references (p. 161-174) and index
    URL: https://learning.oreilly.com/library/view/-/0321278658/?ar
    Library Location Call Number Volume/Issue/Year Availability
    BibTip Others were also interested in ...
    Online Resource
    MPI Ethno. Forsch.
  • 2
    Online Resource
    Online Resource
    Contributing to Eclipse : principles, patterns, and plug-ins (2003)
    Boston : Addison-Wesley | Boston, MA :Safari,
    Details
    Language: English
    Pages: p. cm
    DDC: 005.1
    Keywords: Computer software ; Development ; Electronic books ; local
    Abstract: "Even long-time Eclipse committers will be surprised by the breadth and depth of this book. A must-read for every new Eclipse extender." --Andre Weinand, Eclipse Committer Contributing to Eclipse offers A quick step-by-step tutorial. Have your first plug-in running in less than an hour. An introduction to test-driven plug-in development. Confidently create higher quality plug-ins. The Rules of Eclipse. Seamlessly integrate your contributions with the rest of Eclipse. A design pattern tour of Eclipse. A cook's tour of Eclipse with patterns. A comprehensive tutorial. See all the techniques necessary to write production-quality contributions. Erich Gamma and Kent Beck introduce you quickly, yet thoroughly, to Eclipse, the emerging environment for software development. Instead of simply walking you through the actions you should take, Contributing to Eclipse , with its many sidebars, essays, and forward pointers, guides you through Eclipse. You will not just do . You will also understand . Whether you need to get up to speed immediately or want to better understand the design rationale behind Eclipse, Contributing to Eclipse is the Eclipse resource for you. 0321205758B10142003
    URL: https://learning.oreilly.com/library/view/-/0321205758/?ar
    Library Location Call Number Volume/Issue/Year Availability
    BibTip Others were also interested in ...
    Online Resource
    MPI Ethno. Forsch.
  • 3
    Online Resource
    Online Resource
    Test-driven development : by example (2003)
    Boston : Addison-Wesley | Boston, MA :Safari,
    Details
    Language: English
    Pages: xix, 220 p. , ill. ; , 24 cm
    DDC: 005.1/4
    Keywords: Computer programming ; Computer software ; Development ; Computer software ; Testing ; Electronic books ; local
    Abstract: Clean code that works--now. This is the seeming contradiction that lies behind much of the pain of programming. Test-driven development replies to this contradiction with a paradox--test the program before you write it. A new idea? Not at all. Since the dawn of computing, programmers have been specifying the inputs and outputs before programming precisely. Test-driven development takes this age-old idea, mixes it with modern languages and programming environments, and cooks up a tasty stew guaranteed to satisfy your appetite for clean code that works--now. Developers face complex programming challenges every day, yet they are not always readily prepared to determine the best solution. More often than not, such difficult projects generate a great deal of stress and bad code. To garner the strength and courage needed to surmount seemingly Herculean tasks, programmers should look to test-driven development (TDD), a proven set of techniques that encourage simple designs and test suites that inspire confidence. By driving development with automated tests and then eliminating duplication, any developer can write reliable, bug-free code no matter what its level of complexity. Moreover, TDD encourages programmers to learn quickly, communicate more clearly, and seek out constructive feedback. Readers will learn to: Solve complicated tasks, beginning with the simple and proceeding to the more complex. Write automated tests before coding. Grow a design organically by refactoring to add design decisions one at a time. Create tests for more complicated logic, including reflection and exceptions. Use patterns to decide what tests to write. Create tests using xUnit, the architecture at the heart of many programmer-oriented testing tools. This book follows two TDD projects from start to finish, illustrating techniques programmers can use to easily and dramatically increase the quality of their work. The examples are followed by references to the featured TDD patterns and refactorings. With its emphasis on agile methods and fast development strategies, Test-Driven Development is sure to inspire readers to embrace these under-utilized but powerful techniques. 0321146530B10172002
    URL: https://learning.oreilly.com/library/view/-/0321146530/?ar
    Library Location Call Number Volume/Issue/Year Availability
    BibTip Others were also interested in ...
    Online Resource
    MPI Ethno. Forsch.
  • 4
    Online Resource
    Online Resource
    Planning extreme programming (2001)
    Boston : Addison-Wesley | Boston, MA :Safari,
    Details
    Language: English
    Pages: xvii, 139 p. , ill. ; , 24 cm
    DDC: 005.3
    Keywords: Computer software ; Development ; eXtreme programming ; Electronic books ; local
    Abstract: "XP is the most important movement in our field today. I predict that it will be as essential to the present generation as the S.E.I. and its Capability Maturity Model were to the last." --From the foreword by Tom DeMarco The hallmarks of Extreme Programming--constant integration and automated testing, frequent small releases that incorporate continual customer feedback, and a teamwork approach--make it an exceptionally flexible and effective approach to software development. Once considered radical, Extreme Programming (XP) is rapidly becoming recognized as an approach particularly well-suited to small teams facing vague or rapidly changing requirements--that is, the majority of projects in today's fast-paced software development world. Within this context of flexibility and rapid-fire changes, planning is critical; without it, software projects can quickly fall apart. Written by acknowledged XP authorities Kent Beck and Martin Fowler, Planning Extreme Programming presents the approaches, methods, and advice you need to plan and track a successful Extreme Programming project. The key XP philosophy: Planning is not a one-time event, but a constant process of reevaluation and course-correction throughout the lifecycle of the project. You will learn how planning is essential to controlling workload, reducing programmer stress, increasing productivity, and keeping projects on track. Planning Extreme Programming also focuses on the importance of estimating the cost and time for each user story (requirement), determining its priority, and planning software releases accordingly. Specific topics include: Planning and the four key variables: cost, quality, time, and scope Deciding how many features to incorporate into a release Estimating scope, time, and effort for user stories Prioritizing user stories Balancing the business value and technical risk of user stories Rebuilding the release plan based on customer and programmer input Choosing the iteration length Tracking an iteration What to do when you're not going to make the date Dealing with bugs Making changes to the team Outsourcing Working with business contracts In addition, this book alerts you to the red flags that signal serious problems: customers who won't make decisions, growing defect reports, failing daily builds, and more. An entire chapter is devoted to war stories from the trenches that illustrate the real-world problems many programmers encounter and the solutions they've devised. ...
    Note: Includes index
    URL: https://learning.oreilly.com/library/view/-/0201710919/?ar
    Library Location Call Number Volume/Issue/Year Availability
    BibTip Others were also interested in ...
    Online Resource
    MPI Ethno. Forsch.
  • 5
    Online Resource
    Online Resource
    extreme programming eXplained : embrace change (2000)
    Reading, MA : Addison-Wesley | Boston, MA :Safari,
    Details
    Language: English
    Pages: xxi, 190 p. ; , 24 cm
    DDC: 005.1
    Keywords: Computer software ; Development ; eXtreme programming ; Electronic books ; local
    Abstract: Software development projects can be fun, productive, and even daring. Yet they can consistently deliver value to a business and remain under control. Extreme Programming (XP) was conceived and developed to address the specific needs of software development conducted by small teams in the face of vague and changing requirements. This new lightweight methodology challenges many conventional tenets, including the long-held assumption that the cost of changing a piece of software necessarily rises dramatically over the course of time. XP recognizes that projects have to work to achieve this reduction in cost and exploit the savings once they have been earned. Fundamentals of XP include: Distinguishing between the decisions to be made by business interests and those to be made by project stakeholders. Writing unit tests before programming and keeping all of the tests running at all times. Integrating and testing the whole system--several times a day. Producing all software in pairs, two programmers at one screen. Starting projects with a simple design that constantly evolves to add needed flexibility and remove unneeded complexity. Putting a minimal system into production quickly and growing it in whatever directions prove most valuable. Why is XP so controversial? Some sacred cows don't make the cut in XP: Don't force team members to specialize and become analysts, architects, programmers, testers, and integrators--every XP programmer participates in all of these critical activities every day. Don't conduct complete up-front analysis and design--an XP project starts with a quick analysis of the entire system, and XP programmers continue to make analysis and design decisions throughout development. Develop infrastructure and frameworks as you develop your application, not up-front--delivering business value is the heartbeat that drives XP projects. Don't write and maintain implementation documentation--communication in XP projects occurs face-to-face, or through efficient tests and carefully written code. You may love XP, or you may hate it, but Extreme Programming Explained will force you to take a fresh look at how you develop software. 0201616416B04062001
    URL: https://learning.oreilly.com/library/view/-/0201616416/?ar
    Library Location Call Number Volume/Issue/Year Availability
    BibTip Others were also interested in ...
    Online Resource
    MPI Ethno. Forsch.
  • 6
    Online Resource
    Online Resource
    Refactoring : improving the design of existing code (1999)
    Reading, MA : Addison-Wesley | Boston, MA :Safari,
    Details
    ISBN: 9780133065251 , 0133065251 , 0201485672 , 9780201485677 , 9780133065268 , 013306526X , 9780134757681 , 0134757688 , 0201485672
    Language: English
    Pages: xx1, 431 p. , ill. ; , 25 cm
    Series Statement: The Addison-Wesley object technology series
    Keywords: Software refactoring ; Object-oriented programming (Computer science) ; Electronic books ; local ; Object-oriented programming (Computer science) ; Software refactoring ; COMPUTERS ; Programming ; Object Oriented ; Logiciels ; Refactorisation ; Programmation orientée objet (Informatique)
    Abstract: As the application of object technology--particularly the Java programming language--has become commonplace, a new problem has emerged to confront the software development community. Significant numbers of poorly designed programs have been created by less-experienced developers, resulting in applications that are inefficient and hard to maintain and extend. Increasingly, software system professionals are discovering just how difficult it is to work with these inherited, "non-optimal" applications. For several years, expert-level object programmers have employed a growing collection of techniques to improve the structural integrity and performance of such existing software programs. Referred to as "refactoring," these practices have remained in the domain of experts because no attempt has been made to transcribe the lore into a form that all developers could use. . .until now. In Refactoring: Improving the Design of Existing Code, renowned object technology mentor Martin Fowler breaks new ground, demystifying these master practices and demonstrating how software practitioners can realize the significant benefits of this new process. With proper training a skilled system designer can take a bad design and rework it into well-designed, robust code. In this book, Martin Fowler shows you where opportunities for refactoring typically can be found, and how to go about reworking a bad design into a good one. Each refactoring step is simple--seemingly too simple to be worth doing. Refactoring may involve moving a field from one class to another, or pulling some code out of a method to turn it into its own method, or even pushing some code up or down a hierarchy. While these individual steps may seem elementary, the cumulative effect of such small changes can radically improve the design. Refactoring is a proven way to prevent software decay. In addition to discussing the various techniques of refactoring, the author provides a detailed catalog of more than seventy proven refactorings with helpful pointers that teach you when to apply them; step-by-step instructions for applying each refactoring; and an example illustrating how the refactoring works. The illustrative examples are written in Java, but the ideas are applicable to any object-oriented programming language.
    Note: Includes bibliographical references
    URL: lizenzpflichtig
    Library Location Call Number Volume/Issue/Year Availability
    BibTip Others were also interested in ...
    Online Resource
    MPI Ethno. Forsch.
Close ⊗
This website uses cookies and the analysis tool Matomo. More information can be found here...