Modern Programming: Object Oriented Programming and Best Practices: Deconstruct object-oriented programming and use it with other programming paradigms to build applications

✍ Scribed by Graham Lee

• Publisher: Packt Publishing
• Year: 2019
• Tongue: English
• Leaves: 266
• Edition: 1
• Category: Library

✦ Synopsis

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. Antithesis
2. Thesis
3. Synthesis
4. Tools that Support Software Development
5. Coding Practices
6. Testing
7. Architecture
8. Documentation
9. Requirements Engineering
10. Learning
11. Critical Analysis
12. Business
13. Teamwork
14. Ethics
15. Philosophy

✦ Table of Contents

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

✦ Subjects

Software Development; Object-Oriented Programming; Programming Best Practices; Programming Paradigms