This week's book giveaway is in the Spring forum.
We're giving away four copies of Spring in Action (5th edition) and have Craig Walls on-line!
See this thread for details.
Win a copy of Spring in Action (5th edition) this week in the Spring forum!
    Bookmark Topic Watch Topic
programming forums Java Mobile Certification Databases Caching Books Engineering Micro Controllers OS Languages Paradigms IDEs Build Tools Frameworks Application Servers Open Source This Site Careers Other all forums
this forum made possible by our volunteer staff, including ...
Marshals:
  • Campbell Ritchie
  • Bear Bibeault
  • Devaka Cooray
  • Liutauras Vilda
  • Jeanne Boyarsky
Sheriffs:
  • Knute Snortum
  • Junilu Lacar
  • paul wheaton
Saloon Keepers:
  • Ganesh Patekar
  • Frits Walraven
  • Tim Moores
  • Ron McLeod
  • Carey Brown
Bartenders:
  • Stephan van Hulst
  • salvin francis
  • Tim Holloway
  • Likes 1
  • Mark post as helpful
  • send pies
  • Report post to moderator
  • Other OO references


  • Free books
    • Object-Oriented Reengineering Patterns
    • 2003 by Serge Demeyer, Stéphane Ducasse, Oscar Nierstrasz

      Object-Oriented Reengineering Patterns collects and distills successful techniques in planning a reengineering project, reverse-engineering, problem detection, migration strategies and software redesign.

      Based on the authors' industrial experiences, this book is a guide on how to reverse engineer legacy systems to understand their problems, and then reengineer those systems to meet new demands. Patterns are used to clarify and explain the process of understanding large code bases, hence transforming them to meet new requirements. The key insight is that the right design and organization of your system is not something that can be evident from the initial requirements alone, but rather as a consequence of understanding how these requirements evolve.




    • Seamless Object-Oriented Software Architecture: Analysis and Design of Reliable Systems
    • 1995 by Kim Walden and Jean-Marc Nerson

      This book shows how a consistent set of object-oriented abstractions can be applied throughout the process, based on three major ideas: seamlessness, reversibility, and contracting.

      This book focuses on Business Object Notation(BON) approach and includes case studies, exercises and comprehensive appendices.

      The book is intended for software professionals as well as for students at the graduate and undergraduate levels. We believe it can be read by anyone who has acquired a general understanding of the problems of software engineering, and who has some inclination for abstract thinking.



    • A Functional Pattern System for Object-Oriented Design 1999 by Thomas Kuhne

    • Design patterns inspired by functional programming concepts can advance object-oriented design. This thesis promotes the idea that concepts from the world of functional programming can be captured with design pattern descriptions. These can then be used to benefit from functional programming concepts with ordinary object-oriented languages. The functional patterns are evaluated for their impact on language design and a new approach to a dual-paradigm language is presented.



    • Working With Objects - The OOram Software Engineering Method 1996 byTrygve Reenskaug, P. Wold, O.A. Lehne

    • The main theme of this book is to describe complex phenomena as structures of interacting objects. The goal is to provide a comprehensive description of the object paradigm and its applications, and to show how it supports a number of different views on the same model.

      The object-oriented methodology OOram is new and different from all others on the market, and has been in use and development in Norway for over 12 years. This book is the authoritative account of the OOram methodology for software analysis, design, development, maintenance, and reuse.



    • Object-Oriented Software Composition 1995 by Oscar Nierstrasz and Dennis Tsichritzis

    • Over the part ten years, object-oriented technology has started to have a significant impact in industry. Despite its many positive aspects, there have been some problems in successfully applying the technology to large projects, and in achieving adequate levels of flexibilitly and software reuse.

      Based on the research of the Object Systems Group in Geneva, this book looks at a range of issues, from programming languages and systems through to tools, frameworks and methods.

      KEY FEATURES: Chapters are self-contained, with the development of ideas moving from programming language design issues to environments and applications. Aware of recent trends, the book examines the development of multimedia systems as an application domain. Up-to-date information on the activities of the Object Systems Group. The authors can be found on the World Wide Web.



    • How to Design Classes 2011 by Matthias Felleisen, et al.


    • How to Design Programs (HtDP) 2nd ed by Matthias Felleisen et others (HTML) provides also his opensource programming environment DrRacket (WP)

      The typical course on programming teaches a “tinker until it works” approach. When it works, students exclaim “It works!” and move on. Sadly, this phrase is also the shortest lie in computing, and it has cost many people many hours of their lives. In contrast, this book focuses on habits of good programming, addressing both professional and vocational programmers.

      By “good programming,” we mean an approach to the creation of software that relies on systematic thought, planning, and understanding from the very beginning, at every stage, and for every step. To emphasize the point, we speak of systematic program design and systematically designed programs....



    • Touch of Class: Learning to Program Well with Objects and Contracts 2009 by Bertrand Meyer (some pages)

    • Is this really a book about Eiffel? Perhaps in some senses it is not. It is a book about exactly what the subtitle indicates: Learning to Program Well with Objects and Contracts. (Primary emphasis should fall on the word "Well".) ...



    • Software Innovation: Eight work-style heuristics for creative system developers
    • 2010 by Jeremy Rose

      Innovation is the forgotten key to modern systems development - the element that defines the enterprising engineer, the thriving software firm and the cutting edge software application. Traditional forms of technical education pay little attention to creativity – often encouraging overly rationalistic ways of thinking which stifle the ability to innovate. Professional software developers are often drowned in commercial drudgery and overwhelmed by work pressure and deadlines. The topic that will both ensure success in the market and revitalize their work lives is never addressed. This book sets out the new field of software innovation. It organizes the existing scientific research into eight simple heuristics - guiding principles for organizing a system developer's work-life so that it focuses on innovation.



    • Pride and Paradev: a collection of agile software testing contradictions 2015 by Alister Scott

    • What's a paradev?

      A paradev is anyone on a software team that doesn't just do programming.

      Who's this book for?

      This book is for paradevs who do, or would like to do, software testing on an agile team.

      Why contradictions?

      "The test of a first rate intelligence is the ability to hold two opposed ideas in the mind at the same time, and still retain the ability to function."~ F. Scott Fitzgerald



    • The Architecture of Open Source Applications - Elegance, Evolution, and a Few Fearless Hacks 2011 by Amy Brown and Greg Wilson

    • Architects look at thousands of buildings during their training, and study critiques of those buildings written by masters. In contrast, most software developers only ever get to know a handful of large programs well—usually programs they wrote themselves—and never study the great programs of history. As a result, they repeat one another's mistakes rather than building on one another's successes.

      This book's goal is to change that. In it, the authors of twenty-five open source applications explain how their software is structured, and why. What are each program's major components? How do they interact? And what did their builders learn during their development? In answering these questions, the contributors to this book provide unique insights into how they think....



    • Interface Design: Best Practices in Object-Oriented API Design in Java 2001 by Bill Venners (HTML)

    • my book of object-oriented Java API design guidlines.



    • Objects and Java Building Object-Oriented, Multi-Threaded Applications with Java by Bill Venners

    • Objects and Java covers the Java language and many APIs as well as topics required for successful use of the language and APIs, especially object-oriented techniques and multi-threading.



    • Object-Oriented System Development 1993 by Dennis de Champeaux, Douglas Lea, and Penelope Faure (HTML)

    • The development of a software system is usually just a part of finding a solution to a larger problem. The larger problem may entail the development of an overall system involving software, hardware, procedures, and organizations.

      In this book, we concentrate on the software side. We do not address associated issues such as constructing the proper hardware platform and reorganizing institutional procedures that use the software to improve overall operations. We further limit ourselves to the ``middle'' phases of OO system development. We discuss the initial collection of system requirements and scheduling of efforts only to the extent to which they impact analysis. Similarly, we discuss situation-dependent implementation matters such as programming in particular languages, porting to different systems, and performing release management only with respect to general design issues. Also, while we devote considerable attention to the process of OO development, we do not often address the management of this or any software development process. We urge readers to consult Humphrey [8], among other sources, for such guidance.



    • Domain-Driven Design Quickly
    • 2007 by Abel Avram, Floyd Marinescu

      Domain Driven Design (DDD) is a vision and approach for dealing with highly complex domains that is based on making the domain itself the main focus of the project, and maintaining a software model that reflects a deep understanding of the domain.

      This book is a short, quickly-readable summary and introduction to the fundamentals of DDD; it does not introduce any new concepts; it attempts to concisely summarize the essence of what DDD is, drawing mostly Eric Evans' original book, as well other sources since published such as Jimmy Nilsson's Applying Domain Driven Design, and various DDD discussion forums.

      The main topics covered in the book include: Building Domain Knowledge, The Ubiquitous Language, Model Driven Design, Refactoring Toward Deeper Insight, and Preserving Model Integrity. Also included is an interview with Eric Evans on Domain Driven Design today.



    • Bringing Design to Software
    • 1996 by Terry Winograd (HTML)

      This book aims to illuminate and stimulate the discipline of software design. Collecting insights and experience from experts in diverse fields, it addresses the growing demand that the software industry produce software that really works-software that fits people and situations far better than the examples we see today.

      With Terry Winograd's introductory framework to guide readers through thoughtful essays, perceptive interviews, and instructive profiles of successful projects and programs, the book explores the issues and concerns that most directly influence the functionality, usability, and significance of software. Contributors include some of the most prominent names in the computing and design fields. Programming Languages Survey/Compilers

      Design of software has often taken place in isolation from the many lessons learned in the design of objects or non-computer processes. This collection of essays provides essential inspiration for reflective software designers driven by practical concerns of what works, what doesn't and why.



    • Patterns of Software: Tales from the Software Community
    • 1996 by Richard P. Gabriel

      In Patterns of Software, the respected software pioneer and computer scientist, Richard Gabriel, gives us an informative inside look at the world of software design and computer programming and the business that surrounds them. In this wide-ranging volume, Gabriel discusses such topics as what makes a successful programming language, how the rest of the world looks at and responds to the work of computer scientists, how he first became involved in computer programming and software development, what makes a successful software business, and why his own company, Lucid, failed in 1994, ten years after its inception.

      Perhaps the most interesting and enlightening section of the book is Gabriel's detailed look at what he believes are the lessons that can be learned from architect Christopher Alexander, whose books - including the seminal A Pattern Language--have had a profound influence on the computer programming community. Gabriel illuminates some of Alexander's key insights - "the quality without a name," pattern languages, habitability, piecemeal growth - and reveals how these influential architectural ideas apply equally well to the construction of a computer program. Gabriel explains the concept of habitability, for example, by comparing a program to a New England farmhouse and the surrounding structures which slowly grow and are modified according to the needs and desires of the people who live and work on the farm. "Programs live and grow, and their inhabitants--the programmers - need to work with that program the way the farmer works with the homestead."

      Although computer scientists and software entrepreneurs will get much out of this book, the essays are accessible to everyone and will intrigue anyone curious about Silicon Valley, computer programming, or the world of high technology.



    • The Architecture of Open Source Applications
    • 2011 by Amy Brown, Greg Wilson (HTML)

      Architects look at thousands of buildings during their training, and study critiques of those buildings written by masters. In contrast, most software developers only ever get to know a handful of large programs well—usually programs they wrote themselves—and never study the great programs of history. As a result, they repeat one another's mistakes rather than building on one another's successes.

      Our goal is to change that. In these two books, the authors of four dozen open source applications explain how their software is structured, and why. What are each program's major components? How do they interact? And what did their builders learn during their development? In answering these questions, the contributors to these books provide unique insights into how they think.

      If you are a junior developer, and want to learn how your more experienced colleagues think, these books are the place to start. If you are an intermediate or senior developer, and want to see how your peers have solved hard design problems, these books can help you too.



    • Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design
    • 2001 by Craig Larman

      This book is a lucid and practical introduction to thinking and designing with objects and creating systems that are well crafted, robust, and maintainable.

      Developers and students will learn object-oriented analysis and design (OOA/OOD) through three iterations of two cohesive, start-to-finish case studies. These case studies incrementally introduce key skills, essential OO principles and patterns, UML notation, and best practices. You won't just learn UML diagrams - you'll learn how to apply UML in the context of OO software development.

      Drawing on his unsurpassed experience as a mentor and consultant, Larman helps you understand evolutionary requirements and use cases, domain object modeling, responsibility-driven design, essential OO design, layered architectures, "Gang of Four" design patterns, GRASP, iterative methods, an agile approach to the Unified Process (UP), and much more.



    • UML for Java Programmers
    • 2003 by Robert Cecil Martin

      The Unified Modeling Language has become the industry standard for the expression of software designs. The Java programming language continues to grow in popularity as the language of choice for the serious application developer.

      Using UML and Java together would appear to be a natural marriage, one that can produce considerable benefit. However, there are nuances that the seasoned developer needs to keep in mind when using UML and Java together.

      Software expert Robert Martin presents a concise guide, with numerous examples, that will help the programmer leverage the power of both development concepts. The author ignores features of UML that do not apply to java programmers, saving the reader time and effort. He provides direct guidance and points the reader to real-world usage scenarios. The overall practical approach of this book brings key information related to Java to the many presentations. The result is an highly practical guide to using the UML with Java.



    • UML Process
    • 2005 by Sharam Hekmat

      UML Process is a defined process for developing software systems using object technology. The purpose of this document is to define the UML Process at a level that is suitable for practitioners who have had no prior exposure to a similar process.

      This book is intended to be a concise guide to the UML processes it covers, rather than giving a detailed description of each process. By focusing on the key concepts (and deferring the practical details to workshops and mentoring sessions), we can maximise the usefulness of the handbook as a learning tool.



    • GoF Design Patterns
    • by E.Gamma et al (HTML)

    • Naked Objects by Richard Pawson and Robert Matthews (HTML) on Naked Object framework

    • Most people who believe they are doing object-oriented design and development are doing no such thing, because they are ignoring the most important principle of object-orientation. We describe that principle as 'behavioural completeness': an object should completely model the behaviour of the thing that it represents. Instead, most people continue to design business systems that separate procedure from data, albeit dressed up in the language and technology of object-orientation.

      Why is this distinction important? Because behavioural completeness is the key to realising the principal benefit of object-orientation: the ability to cope with unforeseen changes in requirements....

      The aim of this book is to introduce you to the concept of designing business systems from naked objects, and to enable you to start building such systems using the Naked Objects framework. The book will appeal primarily to two kinds of reader: object modellers who have at least some knowledge of Java programming (or want to acquire it), and Java developers who have some knowledge of object modelling (or want to acquire it). Indeed one of the messages in this book is that the notions of business object modelling and object-oriented programming are much more synergistic than is conventionally realised.




  • Notes on OO


  • Other interesting books



  • WikiPage on free stuff related to OO and Java


  • https://leanpub.com/

  • Here's concentrated a huge repository of freely available programming books for every taste and level, warmly recommended


  • textbookrevolution.org


  • 1,000+ Open Textbooks and Learning Resources for All Subjects


  • FreeTechBooks







  • "Applying UML and Patterns: An Introduction to Object_Oriented Analysis and Design and the Unified Process (2nd Edition)" by Craig Larman ISBN 0130925691

    "Java Design: Building Better Apps and Applets (With CD Rom, 2nd Edition)" by Peter Coad ISBN 0139111816

    "Agile Software Development - Principles, Patterns and Practices" by Robert C. Martin (kind of a second edition of his "Designing Object-Oriented C++ Applications Using the Booch Method") ISBN 0135974445

    "Refactoring: Improving the design of existing code" by Martin Fowler ISBN 0201485672

    "Design Patterns - Elements of Reusable Object-Oriented Software" by Erich Gamma, et al ISBN 0201633612

    Also take a look at the BunkHouse

    related threads:

  • http://www.coderanch.com/t/96584/OO-Patterns-UML-Refactoring/Object-oriented-Design-Java-book
  • http://www.coderanch.com/t/98050/OO-Patterns-UML-Refactoring/OO-books


  • other resources:

  • http://www.objectsbydesign.com/books/booklist.html





  • CategoryBook
     
      Bookmark Topic Watch Topic
    • New Topic
    Boost this thread!