Modern Programming: Object Oriented Programming and Best Practices

Modern Programming: Object Oriented Programming and Best Practices

by Graham Lee
Released June 2019
Publisher(s): Packt Publishing
ISBN: 9781838986186

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

Discover the untapped features of object-oriented programming and use it with other software tools to code fast, efficient applications.

Key Features

  • Explore the complexities of object-oriented programming (OOP)
  • Discover what OOP can do for you
  • Learn to use the key tools and software engineering practices to support your own programming needs

Book Description

Your experience and knowledge always influence the approach you take and the tools you use to write your programs. With a sound understanding of how to approach your goal and what software paradigms to use, you can create high-performing applications quickly and efficiently.

In this two-part book, you'll discover the untapped features of object-oriented programming and use it with other software tools to code fast and efficient applications. The first part of the book begins with a discussion on how OOP is used today and moves on to analyze the ideas and problems that OOP doesn't address. It continues by deconstructing the complexity of OOP, showing you its fundamentally simple core. You'll see that, by using the distinctive elements of OOP, you can learn to build your applications more easily.

The next part of this book talks about acquiring the skills to become a better programmer. You'll get an overview of how various tools, such as version control and build management, help make your life easier. This book also discusses the pros and cons of other programming paradigms, such as aspect-oriented programming and functional programming, and helps to select the correct approach for your projects. It ends by talking about the philosophy behind designing software and what it means to be a "good" developer.

By the end of this two-part book, you will have learned that OOP is not always complex, and you will know how you can evolve into a better programmer by learning about ethics, teamwork, and documentation.

What you will learn

  • Untangle the complexity of object-oriented programming by breaking it down to its essential building blocks
  • Realize the full potential of OOP to design efficient, maintainable programs
  • Utilize coding best practices, including TDD, pair programming and code reviews, to improve your work
  • Use tools, such as source control and IDEs, to work more efficiently
  • Learn how to most productively work with other developers
  • Build your own software development philosophy

Who this book is for

This book is ideal for programmers who want to understand the philosophy behind creating software and what it means to be “good” at designing software. Programmers who want to deconstruct the OOP paradigm and see how it can be reconstructed in a clear, straightforward way will also find this book useful. To understand the ideas expressed in this book, you must be an experienced programmer who wants to evolve their practice.

Table of contents

  1. Preface
    1. About the Book
      1. About the Author
      2. Learning Objectives
      3. Audience
      4. Approach
      5. Acknowledgements
  2. Part One – OOP The Easy Way
    1. About the Example Code
  3. Chapter 1
  4. Antithesis
    1. Telling an Object What to Do
    2. Designing an Object
    3. Drawing an Object
      1. Unified Modeling Language
      2. Class-Responsibility-Collaborator
      3. Jelly Donuts and Soccer Balls
    4. Opposing Functional Programming
      1. Messages Are Just Requests
      2. An Object's Boundary is Just a Function
      3. That Function-Like Boundary? Actually, a Closure Over the Constructor Arguments
    5. Capturing Elements of Reusable Design
    6. Finding a Method to Run
    7. Building Objects
    8. Conclusion to Part One
  5. Chapter 2
  6. Thesis
    1. Objects Are Independent Programs
    2. The Open-Closed Nature of Independent Objects
      1. The Correctness of Independent Objects
    3. The Design of Independent Objects
    4. Constructing Independent Objects
    5. Working with Independent Objects
    6. Conclusion to Part Two
  7. Chapter 3
  8. Synthesis
    1. Objects Are Independent Programs
      1. An Object's Behavior Can Be Described in A Contract
    2. Objects Can Be Written, Inspected, And Changed in Context
    3. Put That All Together
      1. Speed
      2. Tailoring
      3. Propriety
      4. Security
      5. Multiprocessing
      6. Usability
    4. Conclusion to Part Three
  9. Part Two – APPropriate Behavior
  10. Chapter 4
  11. Tools That Support Software Development
    1. Introduction
    2. Version Control/Source Code Management
      1. On Version Control and Collaboration
      2. Distributed Version Control
    3. Continuous Integration and Deployment
      1. Why Use CI?
      2. CI On Real Teams
    4. Build Management
      1. Convention or Configuration
      2. Build Systems That Generate Other Build Systems
    5. Bug and work tracking
      1. What Goes in And When?
      2. How Precisely to Track?
    6. Integrated Development Environment
    7. Static Analysis
    8. Code Generation
      1. Writing Your Own Generator Shouldn't Be A First Resort
      2. When the Generator Won't Be Used by A Programmer
  12. Chapter 5
  13. Coding Practices
    1. Introduction
    2. Test-Driven Development
      1. The point of TDD
      2. The Software I'm Writing Can't Be Tested
      3. So Is Test-Driven Development A Silver Bullet?
    3. Domain-Driven Design
    4. Behavior-Driven Development
    5. xDD
    6. Design by Contract
    7. Development by Specification
    8. Pair programming
      1. Back-Seat Driving Is Not Pair Programming
      2. Being A Silent Partner Is Not Pair Programming
      3. So, Is Pair Programming Just The Balance Between Those Things?
      4. Pair Programming As Programming
      5. Pairing As A Coaching Practice
      6. But Does It Work?
    9. Code Reviews
    10. Programming Paradigms And Their Applicability
      1. Object-Oriented Programming
      2. Aspect-Oriented Programming
      3. Functional Programming
  14. Chapter 6
  15. Testing
    1. Introduction
    2. A Philosophy of Testing
    3. Black and White Boxes
      1. Shining Light on The Black-Box
    4. Test Case Design
      1. Code-Directed Tests
      2. Testing For Non-Functional Requirements
    5. Automate All The Things
    6. Getting Someone Else In
    7. Other Benefits Of Testing
      1. Accessibility
      2. Structure
  16. Chapter 7
  17. Architecture
    1. Introduction
    2. Non-Functional Requirements Are Essential
      1. When Should I Think About the NFRs?
      2. Performance in Low–Fidelity Prototypes
      3. Security in Low-Fidelity Prototypes
      4. Reliability in Low-Fidelity Prototypes
    3. Defer When Appropriate; Commit When Necessary
    4. Justify Your Decisions
    5. When to Fix and When to Replace
    6. Know When to Nitpick, And When to Leave It
    7. Support, Don't Control
      1. What Does A Software Architect Do?
      2. What A Software Architect Doesn't Do
      3. In one sentence
  18. Chapter 8
  19. Documentation
    1. Introduction
    2. Documentation Is More Useful Than You Might Think
    3. The Up-To-Dateness Problem
    4. Automatically Generated Documentation
    5. Analysis Paralysis
    6. How to Document
      1. Coding Standards
      2. Code Comments
      3. Literate Programming
      4. Comment Documentation
      5. Uml Diagrams
    7. Summary
  20. Chapter 9
  21. Requirements Engineering
    1. Study People
      1. Decide The Model
    2. You Shouldn't Necessarily Build What The Client Asks For
    3. Avoid Asking What You Want To Hear
    4. Understand The Problem Domain
    5. Uncover Tacit Requirements
    6. You Shouldn't Build What Your Client Wants
    7. Human Factors In Software Systems
      1. Economics
      2. Politics
    8. Prioritizing Requirements
    9. Is It Really "Engineering"?
  22. Chapter 10
  23. Learning
    1. Introduction
    2. Do as Much as You Can
    3. Don't Stick to Your Own Discipline
    4. Put it into Practice
    5. Collaborate and Share what you Learn
    6. Opportunities to Learn
    7. Rediscovering Lost Knowledge
    8. The Teaching Of Software Creation
    9. Reflective Learning
  24. Chapter 11
  25. Critical Analysis
    1. Introduction
    2. Criticism Is Often Uncritical
    3. How to Form an Argument?
    4. Forms Of Fallacy
      1. Post Hoc, Ergo Propter Hoc
      2. Fundamental Attribution Error
      3. Argument from Fallacy
      4. Continuum Fallacy
      5. Slippery Slope
      6. Begging the Question
      7. Appeal to Novelty
      8. Appeal to the Person
    5. Further Reading on Arguments
    6. Debates and Programmers
    7. Software as Essays
  26. Chapter 12
  27. Business
    1. Introduction
    2. Evaluate Risks Dispassionately
      1. Project Risks
      2. Business Risks
      3. Operational Risks
      4. Other External Risks
      5. Career Risks
      6. Dealing with Risks
    3. Find Out What You Need to Know, And How You Can Know It
    4. What You Discover May Not Be to Your Liking
      1. Personal Experience
    5. How to Interview A Programmer?
      1. Bear the Goal in Mind
      2. The Interview's There for Both of You
      3. What If You Could Avoid Hypothetical Questions?
      4. Don't Try to Prove the Other Person Is Stupid
      5. Personal Experience
    6. Be Transparent and Honest with Your Business Partners
    7. Choose Appropriate Technology
    8. Manipulation and Inspiration
      1. Worked Example: An App Store Sale
    9. You Don't Need to Be A Founder to Be A Programmer
  28. Chapter 13
  29. Teamwork
    1. Introduction
    2. Focus versus Interruption
    3. Working Environment
    4. Prioritizing Work
    5. Tell Experts What Needs to Be Done
    6. Working with Junior Programmers
    7. Working with Managers
    8. Patterns of Software Project Management
      1. Waterfall
      2. Scrum
      3. Lean Software
      4. Anchoring Bias and Project Management
      5. Bias bias
    9. Negotiation
    10. Empathy
      1. The Effect of Mood on Collaboration
      2. Language and Introversion
      3. Knowing What Level to Talk and To Listen At
    11. Shared Language and Shiny Buzzwords
  30. Chapter 14
  31. Ethics
    1. Introduction
    2. Examples of Ethical Codes
    3. Application of The Ethical Code
    4. Ethical Ambiguities
    5. Respecting Privacy
    6. Epilogue
  32. Chapter 15
  33. Philosophy
    1. Introduction
    2. Software as A Pursuit
    3. An Economic Philosophy of Software
      1. Direct Economic Factors
      2. Externalities
      3. Traditional Supply-And-Demand Economics
    4. A Management Philosophy of Software
    5. A Social Philosophy of Software
    6. A Pedagogic Philosophy of Software
    7. What Does It Mean to Be "Good" At Making Software?
    8. Conclusion

Product information

  • Title: Modern Programming: Object Oriented Programming and Best Practices
  • Author(s): Graham Lee
  • Release date: June 2019
  • Publisher(s): Packt Publishing
  • ISBN: 9781838986186