Celebrating 30 Years of Delphi With a New Book: Delphi Quality-Driven Development

-

This year, on February 14th, Delphi celebrates its 30th birthday. Over the past three decades, Delphi has proven to be a robust and versatile development environment, empowering developers to build high-performance applications with ease across multiple platforms: Windows, Linux, Android, iOS, and macOS. 

As we commemorate this milestone, I am also introducing a new book to help guide you into Delphi's fourth decade: Delphi Quality-Driven Development. Useful to lone developers and vast teams alike, this book aims to demonstrate a variety of essential practices and techniques for making high-quality, testable code.

There is a 25% sale going on until the end of February for the Delphi Quality-Driven Development ebook, and there you can also get an additional discount on other books if you add them to your order.

To all my fellow Delphi developers: May your code compile quickly, your memory be manageable, and your code testable.

 

Delphi Quality-Driven Development Book

A practical guide to testing and writing testable code 




Software development is a complex and continuous process. The quality of the end result—the actual software—depends on many variables. Regardless of the size of the team, be it a solo developer, or a team with tens, hundreds, or even thousands of people involved, we cannot always fully control all the aspects of the software development process.

However, we can bring some order into the chaos, and by using well-established and proven practices, we can increase the quality of the software we are producing, and with that, increase customer satisfaction, ultimately improving the success of the software product.

There are always other factors that determine the success (viability) of the software, but a bug-ridden product is never going to be a successful one, unless users are forced to use it for reasons beyond their control.

When it comes to reducing the number of current and future bugs and other quality issues in the software, there is one thing in particular that can and will do more for improving software quality than all the others combined: automated testing.

In that light, the main title of this book could have easily been its subtitle alone: A practical guide to testing and writing testable code. However, the ability to test software requires way more than the mere act of testing or writing testable code, and covering only those two aspects would fail to address other significant factors that contribute not only to the overall quality of the produced software, but also our ability to successfully write and test its code.

While topics surrounding testing and writing testable code do comprise the most significant part of this book, all other parts of the development process that also contribute to the software quality are covered, to give a better understanding of their roles and impact in the whole process. From planning and designing, through development and testing, to deployment.

Besides that, every developer wants to produce high-quality and successful software, while not all of them are very fond of testing. Focusing on testing alone, which many of the testing-related books do, means losing some of the potential audience. What is worse, you lose those that would benefit from it the most.

Testing, you say. I don't have time for this. I have deadlines to meet.

Focusing on the end goal, producing high-quality software, instead of the journey and specific methodology, also allows us to adapt and change the process as we go, instead of sticking to some practice that is not fully applicable to a particular situation.

In our search for successful practices that will help us in doing our job better and faster, we tend to forget why we are using them. All those good practices don't exist in a void for their own sake: They evolved through our collective knowledge, being adapted, tweaked, and polished until they emerged under some name, to be more easily recognizable and approachable.

But in that effort to categorize and simplify the message we are sending to new generations of developers, we often fail to explain its origins and real purpose, passing only half of the knowledge until it degenerates into something that causes more harm than good. And then old practices are quickly abandoned without realizing the reasons for their failure, and new practices emerge, only to fail soon enough.

This is another reason for choosing the title Quality-Driven Development: it can be whatever you need it to be. It is a timeless reminder of your goals, insisting on practical know-how, instead of following and sticking with very specific, rigidly formed processes. And while you will still need to use at least some of those established practices to achieve your goals, you can more freely adapt them to serve you, rather than the other way around.

Larger companies and teams are more likely to use automated testing and other processes that contribute to software quality. Small teams and single developers, not so much. The need to ship a product on time, combined with a lack of resources to follow all the necessary steps to produce high-quality software, is always a great incentive to cut corners. Of course, larger teams are no strangers to cutting corners either, and this book is intended for all of the above, as its goal is not only to teach how to do something and how to apply a certain process, but also why all those pesky, time-consuming tasks are actually saving time and not wasting it.


 

Table of Contents:

Introduction

Part 1. Software Development Process

* Quality Factors

* Software Development Cycle

* Work Smarter, Not Harder

* Don’t Let Rules Rule

* Use the Source, Luke!

   + Version Control Systems and Terminology
   + Git, GitHub... I don’t git it

* Working With Git

   + Creating a Repository
     - .gitattributes configuration file
     - .gitignore configuration file
     - Adding files and committing changes
   + Branching and Merging
     - Single branch
     - Trunk-based development (GitHub flow)
     - Git flow
     - Master-Develop-Feature
     - Merge vs Rebase
     - Resolving and avoiding merge conflicts

* Issue Tracking Systems

Part 2. Documentation, Planning, and Design

* Software Project Documentation

   + Minimum Viable Product and Future Extensions

* Start, Planning, and Design

   + Concept Document - White Paper
   + Software Requirements Specification
   + Software Design Document

* Source Code and API Documentation

* Testing Documentation

   + Test Case
   + Test Case Scenario
   + Test Case Document

Part 3. Introduction to Testing

* Development and Testing

   + Test Early
   + Manual Testing
   + Unit Testing
   + Integration Testing
   + System Testing
   + Acceptance Testing

* Introduction to Unit Testing

   + Manual Testing
   + Unit Testing 
   + DUnit Template Wizard
   + DUnit Test Workflow
   + Writing and Running Simple Tests
   + Extending the Test Suite 
   + Testing Corner Cases
   + Testing Exceptions 
   + Testing the Destruction Process 
   + DUnit Validation Methods

* Testing with DUnitX

   + DUnitX Validation Methods
   + Running DUnitX in GUI  
   + DUnit vs DUnitX
   + Migrating from DUnit to DUnitX

* DUnit Extensions

* TestInsight

* Unit Testing Principles

   + Test Repeatability 
   + Speed  
   + Code Paths and Functionality Coverage
   + Testing Implementation Details 
   + Testing in Isolation 
   + Single Test Case per Unit Test
   + Test Granularity

* Test Doubles

   + Dummy Test Double
   + Fake Test Double
   + Stub Test Double
   + Spy Test Double 
   + Mock Test Double

* Test-Driven Development - TDD

  + Red-Green-Refactor Steps 
  + Refactoring
    - Internal refactoring
    - External refactoring
   + Speeding Up the TDD Process
   + Follow TDD or Not?
   + False Expectations

* Think Before You Code

Part 4. Test Cases

* Test Cases

* Testing Methodologies

   + Black-Box Testing Methodologies 
   + White-Box Testing Methodologies

* Black-Box Testing

   + Equivalence Partitioning & Boundary Value Analysis 
   + Decision Tables
   + Cause–effect Graph
   + State Transition Testing
   + Classification Trees

* White-Box Testing

   + Static Code Analysis 
   + Control Flow Graph
   + Statement Coverage
   + Branch (Decision) Coverage
   + Path Coverage
   + Basic and Multiple Condition Coverage 
   + Function Coverage 
   + Loop Testing 
   + Data Flow Testing

* White-Box Metrics

   + Cyclomatic Complexity Metric
   + Rapps-Weyuker Metrics

* Code Coverage Tools

* Test Data & Scenarios

   + Valid Data or Scenario 
   + Invalid Data or Scenario
   + Special-Context Values 
   + Boundaries & Data Around Boundaries 
   + Booleans 
   + Enumerated Types 
   + Integer Numbers 
   + Floating-Point Numbers
   + Fixed-Point Numbers 
   + Date and Time 
   + Pointers, Objects, and Interfaces 
   + Procedural Types
   + Records
   + Arrays and Buffers
   + Characters and Strings 
     - Specifications 
     - Choosing the best string type 
     - Indexed string access 
     - Character buffers allocation 
   + Collections and Sets  
   + Variant Types

Part 5. Development & Testing

* Writing Testable Code

* Never Say Never: Existing Code

* Global State

   + Minimizing Usage of Global State
   + Changing Global State
   + Wrapping Global State
     - Procedural Types
     - Singletons

* Dependencies & Decoupling

   + Dependencies
     - Heavyweight dependencies
     - Simple, commonly used classes
     - Dependency is an integral part of the system under test
     - Code performance and complexity 
     - Unit testing performance
     - Other considerations
   + Dependency Injection 
     - Constructor injection
     - Property or field injection
     - Method injection
     - Factory method 
     - Abstract factory
     - Dependency injection container
     - Metaclasses
   + Dependency Architecture 
     - Interfaces
     - Classes and metaclasses 
     - Adapter and facade patterns

* Testing Generics

* Testing Multithreaded Code

   + Extract Unrelated Functionality
     - Thread and task termination
     - Communicating with GUI
   + Waiting for Threads or Tasks
   + Testing Thread Safety
   + Anonymous Methods

* Integration Testing

* Testing GUI

  + Extract Testable Code 
  + Add Abstraction Layers
  + Use Messaging Systems

Part 6. Integration & Deployment

* Integration & Deployment

* Integration & Deployment Automation

   + Automation Tools 
   + Build
   + Test
   + Deliver & Deploy

Appendix

* References

Comments

Post a Comment

Popular posts from this blog

Delphi 12.1 & New Quality Portal Released

-
Image
The Delphi 12.1 update has been released. Besides a number of bug fixes, this release also has a few new features. The most notable ones are the new Split Editor, which allows having multiple files opened side by side; and support for Android API 34. You can find more information about what is new in this update at https://docwiki.embarcadero.com/RADStudio/Athens/en/12_Athens_-_Release_1 However, the greatest change for all Delphi developers is a new bug tracking portal that replaces the old one, still available in read-only mode at https://quality.embarcadero.com/ . The new portal is hosted in Atlassian Cloud https://embt.atlassian.net/servicedesk/customer/portals  or through a redirect https://qp.embarcadero.com and is based on Jira Service Management (JSM), while the internal bug tracking system, which was also migrated to the cloud, was not changed and is running on Jira. This move to the cloud was inevitable, because Atlassian retired their Server line of products. JSM i...
Read more

Assigning result to a function from asynchronous code

-
One of the more common problems that comes up in multi-threading, especially when refactoring existing code, is assigning a result obtained from asynchronous code. In other words, how do you write a function that will return some value, and calculate that value in a background thread? Basically, converting the following code: function GetData(...): string; var Data: string; begin Data := LongTask(...); // assign result of a long-running task to a function Result := Data; end; To this one: function GetData(...): string; var Data: string; begin TThread.CreateAnonymousThread( procedure begin Data := LongTask(...); end).Start; // assign result of a long-running task to a function Result := Data; end; Now, the above code will compile, but it will not achieve the desired functionality. Even if we ignore its thread safety issues (the background thread writes to the Data variable and that can interfere with assigning it to the function result), the funct...
Read more

Coming in Delphi 12: Disabled Floating-Point Exceptions

-
Delphi 12 is in the works. One of its small features that will have a huge impact is a change in the default handling of floating-point exceptions, which will now be masked on all platforms. Previously, floating-point exception handling was different across platforms, and most notably on the Windows platform: In VCL and console applications, floating-point exceptions were not masked and would raise an exception. On the other hand, FireMonkey applications had all floating-exceptions masked by default, regardless of which platform they were running on. Basically if you haven't explicitly changed the exception mask in your code to some value other than the default, and you had code that attempted to divide some number with zero, you would get an EZeroDivide exception in previous Delphi versions on the Windows VCL application. In Delphi 12, there is no exception, and the result of such a division will be +INF . So the following code will no longer raise an exception. If you were r...
Read more