Further Reading — Chapter 16: Introduction to Object-Oriented Programming

Official Documentation

  • Free Pascal Reference Guide — Chapter 6: Classes https://www.freepascal.org/docs-html/ref/refch6.html The authoritative specification of class types in Free Pascal, including all visibility specifiers, property syntax, and class methods. Dense but precise. Read this when you need to know exactly how the language works.

  • Free Pascal Reference Guide — Objects https://www.freepascal.org/docs-html/ref/refch5.html Covers the older "object" type (Turbo Pascal style) as distinct from the "class" type. Useful for understanding legacy code, but for new code, always use class.

  • Lazarus Wiki: Object-Oriented Programming with Free Pascal https://wiki.lazarus-ide.org/Object_Oriented_Programming_with_Free_Pascal_and_Lazarus A practical guide with worked examples. Good bridge between reference documentation and real-world usage.

Books

  • Marco Cantu, Object Pascal Handbook (latest edition) The definitive book on Object Pascal as implemented in Delphi and Free Pascal. Chapters 10-14 cover classes, objects, constructors, destructors, and properties in depth. Cantu writes with clarity and precision. If you buy one supplementary book for this course, make it this one.

  • Niklaus Wirth, Algorithms + Data Structures = Programs (1976) Wirth's classic that inspired this textbook's Theme 5. While it predates OOP, the fundamental insight — that programs are the combination of algorithms and data structures — is exactly what classes formalize. The transition from records+procedures to classes is the natural culmination of Wirth's vision.

  • Grady Booch, Object-Oriented Analysis and Design with Applications (3rd ed., 2007) A language-agnostic treatment of OOP principles and design. Booch is one of the creators of UML and a pioneer of OOP methodology. The early chapters on objects, classes, and relationships are excellent conceptual foundations.

  • Bertrand Meyer, Object-Oriented Software Construction (2nd ed., 1997) A rigorous, deeply thoughtful treatment of OOP by the creator of Eiffel. Meyer's concept of "Design by Contract" — where classes explicitly state their preconditions, postconditions, and invariants — extends the encapsulation ideas from this chapter. Dense but rewarding.

  • Michaël Van Canneyt (ed.), Free Pascal Programmer's Guide https://www.freepascal.org/docs-html/prog/prog.html Covers practical aspects of Free Pascal programming, including memory management, compiler modes ({$mode objfpc}` vs `{$mode delphi}), and debugging object-oriented code.

Articles and Online Resources

  • "Alan Kay on the Meaning of Object-Oriented Programming" (2003 email) http://www.purl.org/stefan_ram/pub/doc_kay_oop_en Alan Kay, who coined the term "object-oriented programming," explains what he originally meant by it. Surprisingly, his emphasis was on messaging between objects rather than on classes and inheritance. A thought-provoking perspective.

  • Robert C. Martin, "The SOLID Principles of Object-Oriented Design" Various articles at https://blog.cleancoder.com/ SOLID is an acronym for five design principles that guide OOP: Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. We will encounter these throughout Part III, but reading about them early provides useful context.

  • Dmitry Boyarintsev, "Object Pascal Style Guide" https://castle-engine.io/coding_conventions The Castle Game Engine coding conventions for Object Pascal. Demonstrates professional naming conventions (the T, F, A prefixes we use in this chapter), file organization, and class design patterns in production code.

Historical Perspective

  • Ole-Johan Dahl and Kristen Nygaard, "SIMULA — An ALGOL-Based Simulation Language" (1966) The paper that introduced classes and objects to programming. SIMULA, created in Norway for simulation, is the direct ancestor of every OOP language including Object Pascal, C++, Java, and Python. Understanding its origins as a simulation language explains why OOP maps so naturally to modeling real-world entities.

  • Borland, Object-Oriented Programming with Turbo Pascal (1989) Historical context for how OOP came to Pascal. Borland's extension of Pascal with objects (later refined into Delphi's class model) was one of the most commercially successful OOP implementations of the late 1980s and 1990s.

Practice Resources

  • "Pascal Objects and Classes" exercises on Rosetta Code https://rosettacode.org/wiki/Category:Pascal Search for object-oriented tasks to see how Pascal compares with other languages for common OOP problems.

  • Project Euler (https://projecteuler.net/) While not OOP-specific, many problems benefit from being modeled with classes. Try solving problems 1-20 using OOP design — create classes to represent the mathematical entities involved.

Looking Ahead

The ideas in this chapter — classes, objects, encapsulation, constructors/destructors — are the foundation. Chapter 17 builds on them with inheritance and polymorphism, which allow classes to form hierarchies where descendant classes extend and specialize ancestor behavior. Chapter 18 adds interfaces and abstract classes, which define contracts that unrelated classes can fulfill. Together, these three chapters form the complete OOP toolkit.

For readers who want to read ahead on inheritance and polymorphism, the relevant sections of Marco Cantu's Object Pascal Handbook and the Free Pascal Reference Guide Chapter 6 cover these topics in the same class model we are using.