Appendix J: Bibliography

This bibliography follows the textbook's three-tier citation honesty system. Every source used in this textbook is classified according to the level of verification the authors can provide. We believe this transparency — rare in textbooks — is more honest than presenting all sources with equal confidence.

Tier 1: Verified Sources

These are real publications that have been verified by the authors. Full bibliographic information is provided. Page numbers and edition details are accurate to the best of our knowledge.

Pascal Language and Ecosystem

Cantu, M. (2020). Object Pascal Handbook: Delphi 10.4 Sydney Edition. Piacenza, Italy: Wintech Italia.

The definitive modern reference for Object Pascal as implemented in Delphi. Referenced throughout Parts III, V, and VI for OOP features, generics, and advanced language constructs.

Duntemann, J. (2020). FreePascal from Square One: A Gentle Introduction to Programming in FreePascal for Beginners. Self-published.

A beginner-friendly introduction to Free Pascal programming. Referenced in Chapter 1 for historical perspective and in Appendix B for installation guidance.

Free Pascal Development Team. (2024). Free Pascal Reference Guide, version 3.2.2. Retrieved from https://www.freepascal.org/docs-html/ref/ref.html

The official language reference for the Free Pascal compiler. Used extensively for verifying language syntax, type compatibility rules, compiler directives, and platform-specific behavior.

Free Pascal Development Team. (2024). Free Pascal Programmer's Guide, version 3.2.2. Retrieved from https://www.freepascal.org/docs-html/prog/prog.html

Practical guide to Free Pascal development. Referenced for compiler options, linking modes, conditional compilation, and platform targeting.

Free Pascal Wiki Contributors. (2024). Free Pascal Wiki. Retrieved from https://wiki.freepascal.org/

Community-maintained documentation covering a wide range of Free Pascal topics. Referenced for tutorials, component documentation, and community conventions.

Lazarus Wiki Contributors. (2024). Lazarus IDE Wiki. Retrieved from https://wiki.lazarus-ide.org/

The primary documentation source for Lazarus IDE, LCL components, and GUI development. Referenced extensively in Part V (Chapters 27-32).

Wirth, N. (1971). The Programming Language Pascal. Acta Informatica, 1(1), 35-63.

The original paper defining the Pascal language. This is where it all began. Referenced in Chapter 1 for historical context and language design philosophy.

Wirth, N. (1973). Systematic Programming: An Introduction. Englewood Cliffs, NJ: Prentice-Hall.

Wirth's approach to teaching programming as a systematic discipline. Its philosophy pervades this textbook's pedagogical approach.

Wirth, N. (1976). Algorithms + Data Structures = Programs. Englewood Cliffs, NJ: Prentice-Hall.

The seminal work that defines the equation at the heart of computer science. Referenced throughout Part II (data structures) and Part IV (algorithms), and cited by title in Chapter 1.

Wirth, N. (1985). Programming in Modula-2 (3rd ed.). Berlin: Springer-Verlag.

Documents Wirth's successor language to Pascal, introducing modules and separate compilation. Referenced in Chapter 40 for the evolution of Wirth's language family.

Wirth, N. (2004). A Brief History of Software Engineering. IEEE Annals of the History of Computing, 26(4), 74-81.

Wirth's retrospective on the evolution of software development practices. Referenced in Chapters 1 and 40 for Wirth's Law and the philosophy of software simplicity.

Computer Science Fundamentals

Abelson, H., & Sussman, G. J. (1996). Structure and Interpretation of Computer Programs (2nd ed.). Cambridge, MA: MIT Press.

A classic text on computational abstraction and programming. Referenced in Chapters 7 and 22 for the distinction between procedural and data abstraction, and for the conceptual foundations of recursion.

Aho, A. V., Lam, M. S., Sethi, R., & Ullman, J. D. (2006). Compilers: Principles, Techniques, and Tools (2nd ed.). Boston: Addison-Wesley.

The "Dragon Book." Referenced for understanding compilation, type checking, and symbol table management as discussed in Chapters 2 and 33.

Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2022). Introduction to Algorithms (4th ed.). Cambridge, MA: MIT Press.

The standard algorithms textbook (CLRS). Referenced throughout Part IV for algorithm analysis, sorting algorithms, tree algorithms, and complexity theory.

Dale, N., & Weems, C. (2014). Programming and Problem Solving with Delphi. Sudbury, MA: Jones & Bartlett Learning.

A Pascal/Delphi-specific CS1 textbook that informed some of the exercise designs in Parts I and II. Referenced for its pedagogical ordering of topics.

Dijkstra, E. W. (1968). Go to Statement Considered Harmful. Communications of the ACM, 11(3), 147-148.

The famous letter advocating structured programming over GOTO. Referenced in Chapter 1 for the intellectual context in which Pascal was designed.

Dijkstra, E. W. (1972). The Humble Programmer. Communications of the ACM, 15(10), 859-866.

Dijkstra's Turing Award lecture, arguing that intellectual manageability should be the primary concern in programming. Referenced in Chapter 1 for the philosophical foundations of structured programming and in Chapter 40 for the enduring relevance of programming discipline.

Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Reading, MA: Addison-Wesley.

The "Gang of Four" design patterns book. Referenced in Chapters 18 and 21 for the Strategy, Observer, Template Method, and Factory patterns.

Hoare, C. A. R. (1962). Quicksort. The Computer Journal, 5(1), 10-16.

The original paper on the quicksort algorithm. Referenced in Chapter 23.

Hoare, C. A. R. (1969). An Axiomatic Basis for Computer Programming. Communications of the ACM, 12(10), 576-580.

Foundational paper on formal reasoning about program correctness. Referenced in Chapter 6 for the concept of loop invariants and in Chapter 26 for understanding algorithmic correctness proofs.

Knuth, D. E. (1974). Structured Programming with go to Statements. ACM Computing Surveys, 6(4), 261-301.

Knuth's nuanced response to the GOTO debate, arguing that structured programming is a mindset, not merely a syntax restriction. Referenced in Chapter 1 for a balanced view of the structured programming revolution.

Knuth, D. E. (1997). The Art of Computer Programming, Volume 1: Fundamental Algorithms (3rd ed.). Reading, MA: Addison-Wesley.

The encyclopedic reference on algorithms. Referenced in Chapters 22, 23, and 26 for algorithm analysis and mathematical rigor.

Knuth, D. E. (1998). The Art of Computer Programming, Volume 3: Sorting and Searching (2nd ed.). Reading, MA: Addison-Wesley.

Comprehensive treatment of sorting and searching algorithms. Referenced in Chapter 23.

Liskov, B. H., & Wing, J. M. (1994). A Behavioral Notion of Subtyping. ACM Transactions on Programming Languages and Systems, 16(6), 1811-1841.

The formal definition of the Liskov Substitution Principle. Referenced in Chapter 17 for understanding proper inheritance design.

Martin, R. C. (2002). Agile Software Development: Principles, Patterns, and Practices. Upper Saddle River, NJ: Prentice Hall.

Introduces SOLID principles (Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion). Referenced in Chapters 17, 18, and 33 for OOP design principles.

Martin, R. C. (2008). Clean Code: A Handbook of Agile Software Craftsmanship. Upper Saddle River, NJ: Prentice Hall.

Practical guidelines for writing readable, maintainable code. Referenced in Chapters 7, 8, and 33 for naming conventions, function design, and code organization.

Meyer, B. (1997). Object-Oriented Software Construction (2nd ed.). Upper Saddle River, NJ: Prentice Hall.

Comprehensive treatment of OOP with the concept of "Design by Contract." Referenced in Chapters 16, 17, and 18 for the theoretical foundations of object-oriented programming, class invariants, and preconditions/postconditions.

Parnas, D. L. (1972). On the Criteria to Be Used in Decomposing Systems into Modules. Communications of the ACM, 15(12), 1053-1058.

The foundational paper on information hiding and modular design. Referenced in Chapter 33 for the principles behind Pascal's unit system.

Sedgewick, R., & Wayne, K. (2011). Algorithms (4th ed.). Boston: Addison-Wesley.

A modern algorithms textbook with excellent visualizations. Referenced in Part IV for alternative explanations of sorting, searching, and graph algorithms.

Stroustrup, B. (2013). The C++ Programming Language (4th ed.). Upper Saddle River, NJ: Addison-Wesley.

The definitive C++ reference by its creator. Referenced in Chapters 1 and 40 for comparing Pascal's and C++'s approaches to static typing, OOP, and generics.

Software Engineering and History

Booch, G. (2007). Object-Oriented Analysis and Design with Applications (3rd ed.). Boston: Addison-Wesley.

A foundational text on object-oriented design methodology. Referenced in Parts III and VII for design principles and the relationship between analysis and implementation.

Brooks, F. P. (1995). The Mythical Man-Month: Essays on Software Engineering (Anniversary ed.). Reading, MA: Addison-Wesley.

Classic essays on software project management. Referenced in Chapter 38 (capstone) for the concept of conceptual integrity and in Chapter 33 for modular design.

Hejlsberg, A., Wiltamuth, S., & Golde, P. (2003). The C# Programming Language. Boston: Addison-Wesley.

Documents C#, designed by the creator of Turbo Pascal. Referenced in Chapters 1 and 40 for Pascal's influence on modern languages.

Hunt, A., & Thomas, D. (1999). The Pragmatic Programmer: From Journeyman to Master. Boston: Addison-Wesley.

Influential guide to professional software development practices. Referenced in Chapters 2, 19, and 33 for debugging strategies, defensive programming, and the DRY (Don't Repeat Yourself) principle.

Kernighan, B. W. (1981). Why Pascal is Not My Favorite Programming Language. Bell Labs Computing Science Technical Report No. 100.

A famous critique of Pascal's limitations. Referenced in Chapter 1 and Chapter 40 as part of the honest discussion of Pascal's historical weaknesses and how modern implementations address them.

McConnell, S. (2004). Code Complete: A Practical Handbook of Software Construction (2nd ed.). Redmond, WA: Microsoft Press.

A comprehensive guide to writing high-quality code. Referenced in Chapters 7, 8, 16, and 33 for naming conventions, variable initialization, defensive programming, and code review practices.

Swaine, M., & Freiberger, P. (2000). Fire in the Valley: The Making of the Personal Computer (2nd ed.). New York: McGraw-Hill.

History of the personal computer revolution, including Borland and Turbo Pascal. Referenced in Chapter 1 for historical context of Pascal's commercial success in the 1980s.

Database and Networking

Date, C. J. (2003). An Introduction to Database Systems (8th ed.). Boston: Addison-Wesley.

The standard database textbook. Referenced in Chapter 31 for relational database theory, SQL semantics, and normalization principles.

Fielding, R. T. (2000). Architectural Styles and the Design of Network-based Software Architectures. Doctoral dissertation, University of California, Irvine.

The dissertation that defined REST. Referenced in Chapter 35 for REST API design principles.

SQLite Consortium. (2024). SQLite Documentation. Retrieved from https://www.sqlite.org/docs.html

Official SQLite documentation. Referenced in Chapter 31 for SQL syntax, data types, and best practices.

Stevens, W. R., Fenner, B., & Rudoff, A. M. (2003). UNIX Network Programming, Volume 1: The Sockets Networking API (3rd ed.). Boston: Addison-Wesley.

The definitive reference on socket programming. Referenced in Chapter 35 for TCP/IP concepts.

Tanenbaum, A. S., & Wetherall, D. J. (2011). Computer Networks (5th ed.). Boston: Pearson.

Comprehensive treatment of networking from physical layer to application layer. Referenced in Chapter 35 for understanding the TCP/IP protocol stack and HTTP semantics.

Pedagogy and Computer Science Education

Guzdial, M. (2015). Learner-Centered Design of Computing Education: Research on Computing for Everyone. San Rafael, CA: Morgan & Claypool.

Research on how people learn computing. Informed the textbook's pedagogical design, particularly the use of progressive projects, prediction exercises, and metacognitive reflection prompts.

Robins, A., Rountree, J., & Rountree, N. (2003). Learning and Teaching Programming: A Review and Discussion. Computer Science Education, 13(2), 137-172.

A comprehensive review of research on programming education. Informed the textbook's approach to introducing variables, loops, and recursion — topics where novice difficulties are well-documented.

Soloway, E. (1986). Learning to Program = Learning to Construct Mechanisms and Explanations. Communications of the ACM, 29(9), 850-858.

Foundational research on programming misconceptions. Informed the exercise design throughout, particularly the prediction-then-verify pattern used in Part B exercises across all chapters.

Concurrency

Butenhof, D. R. (1997). Programming with POSIX Threads. Reading, MA: Addison-Wesley.

Referenced in Chapter 36 for threading fundamentals: mutexes, condition variables, and thread safety.

Herlihy, M., & Shavit, N. (2012). The Art of Multiprocessor Programming (Revised 1st ed.). Burlington, MA: Morgan Kaufmann.

Referenced in Chapter 36 for concurrent data structures and synchronization principles.

Tier 2: Attributed Claims

These are claims, statistics, or historical facts attributed to specific sources where we have high confidence in the attribution but have not verified every bibliographic detail (exact page numbers, edition, or publication date). We include them because the information is valuable, but we flag them as not fully verified.

The claim that "Turbo Pascal compiled at over 10,000 lines per second on a 4.77 MHz IBM PC" is widely attributed to Borland's marketing materials and contemporary reviews in Byte magazine (circa 1983-1984). The exact figure varies by source.

The assertion that Anders Hejlsberg wrote the Turbo Pascal compiler entirely in assembly language is widely reported in computing histories and interviews, including accounts in Computer Language magazine and Michael Swaine and Paul Freiberger's Fire in the Valley.

The ranking of Delphi/Object Pascal in the TIOBE Index and other language popularity indices is based on monthly snapshots from https://www.tiobe.com/tiobe-index/. Rankings fluctuate; specific placements cited in Chapter 39 reflect approximate values at the time of writing.

The claim that FL Studio (Image-Line), Total Commander (Christian Ghisler), and Skype's original Windows client were written in Delphi/Object Pascal is based on developer statements and community knowledge. Image-Line has publicly confirmed Delphi usage; Ghisler has confirmed Total Commander's Delphi heritage; the Skype claim is widely reported but harder to verify as the codebase has been rewritten multiple times since Microsoft's acquisition.

The historical account of Blaise Pascal building the Pascaline calculator for his father (a tax commissioner) is drawn from standard mathematical histories, including Carl Boyer's A History of Mathematics (Wiley, 1968) and various Pascal biographies. The specific date of 1642 for the first working model is conventional but not universally agreed upon.

The description of the AP Computer Science exam's language transitions (Pascal 1984-1998, C++ 1999-2003, Java 2004-present) is based on College Board publications and historical accounts available on the AP Central website.

Dijkstra's advocacy for Pascal as a teaching language is documented in his EWD manuscripts (available at the University of Texas archives), particularly EWD498 ("How do we tell truths that might hurt?") and his Turing Award lecture.

The claim that the Free Pascal compiler targets more than 20 processor architectures and the LCL supports more than 10 widgetsets is based on Free Pascal documentation. Exact counts change with each release.

The statement that structured programming reduced bug rates in commercial software by 25-50% compared to unstructured code is attributed to various software engineering studies from the 1970s and 1980s, summarized in retrospective accounts by Dijkstra, Wirth, and others. We have not located a single definitive study with this exact figure; it represents a commonly cited approximation from the era.

The observation that "students who learn Pascal first perform better in subsequent programming courses" is based on anecdotal reports from multiple university computer science departments that used Pascal as a CS1 language in the 1980s and 1990s, particularly accounts from ETH Zurich, Stanford, and UC Berkeley. Controlled experimental studies comparing Pascal-first versus Python-first cohorts are, to our knowledge, not available in the published literature as of the time of writing.

The description of Wirth's influence on the development of the Oberon operating system and the associated hardware (Ceres workstation) is based on Wirth's published accounts in Project Oberon: The Design of an Operating System and Compiler (Wirth & Gutknecht, 1992, Addison-Wesley) and subsequent updates. We cite this as Tier 2 because we reference the work but have not verified every specific claim about hardware specifications.

Tier 3: Illustrative and Fictional

These are case studies, composite examples, characters, datasets, and scenarios created specifically for this textbook. They are pedagogical tools, not reports of real events. Any resemblance to real persons, projects, or companies is coincidental.

Running Example Characters

Rosa Martinelli — Fictional freelance graphic designer who uses the PennyWise application throughout the textbook to manage her business and personal finances. Introduced in Chapter 1. Her character arc illustrates the progressive evolution of a software project from a simple command-line tool to a full-featured GUI application.

Tomas Vieira — Fictional college student and second user persona for PennyWise. Introduced in Chapter 1. His character represents the budget-conscious student use case and provides opportunities to explore different feature requirements and user experience considerations.

Running Example Projects

PennyWise Personal Finance Manager — The textbook's progressive project. A fictional personal finance application that evolves from a one-file command-line program (Chapter 3) to a cross-platform GUI application with SQLite database, REST API sync, and multithreaded background operations (Chapter 38). All code is original to this textbook.

Crypts of Pascalia — A fictional text adventure game engine used as a secondary running example, primarily in chapters covering game-relevant concepts (loops, data structures, OOP). Introduced in Chapter 6. All game content, room descriptions, and puzzle designs are original to this textbook.

GradeBook Pro — A fictional grade management system used as a third running example, primarily in chapters covering arrays, records, files, and database programming. Introduced in Chapter 9. All academic scenarios and grade data are fictional.

MicroServe — A fictional lightweight HTTP server and REST API framework used in Chapters 34-37 to demonstrate networking, file format handling, and system programming concepts. All API designs and server architectures are original.

Fictional Scenarios and Case Studies

All employer scenarios, interview questions, "war stories," debugging anecdotes, and workplace situations presented in case studies and exercises are composite fictional constructions. They are designed to illustrate realistic programming situations but do not describe actual events at real companies.

The "Tomás's budget crisis" scenario (Chapter 5), "Rosa's client invoice problem" (Chapter 13), "the GradeBook data corruption incident" (Chapter 19), and similar narrative vignettes are entirely fictional.

Code Examples

All Pascal source code in this textbook is original, written specifically for instructional purposes. While some algorithms (quicksort, binary search, linked list operations, etc.) follow well-known patterns described in the computer science literature, the specific implementations, variable names, comments, and pedagogical structure are original to this textbook.

The PennyWise code is not based on any real financial application. The Crypts of Pascalia game engine is not based on any real game. All code is released under the textbook's license for educational use.

Fictional Narratives and Anecdotes

The chapter-opening narratives — such as Rosa Martinelli debugging her first PennyWise version at 2 AM (Chapter 19), Tomas discovering a budget discrepancy that revealed a rounding error (Chapter 3), and Rosa presenting PennyWise 2.0 to her small business owners' group (Chapter 38) — are entirely fictional. They are designed to humanize the learning experience and provide motivational context for technical concepts.

The "What Would Wirth Think?" sidebars that appear in several chapters are speculative editorial commentary based on Wirth's published writings. They are the textbook authors' interpretation of how Wirth's design philosophy applies to modern programming challenges. They do not represent actual statements by Niklaus Wirth.

The interview question compilations at the end of selected chapters ("What an Employer Might Ask") are composite questions drawn from general software engineering interview practice. They do not represent actual interview questions from specific companies.

Datasets and Sample Files

All CSV files, JSON examples, XML documents, database schemas, and binary file format specifications presented in exercises and examples are synthetic, created for instructional purposes. They are not derived from real-world datasets. The PennyWise expense data, GradeBook student records, and MicroServe API payloads are all fictional.

A Note on Citation Practice

This textbook adopts the three-tier citation system because we believe intellectual honesty requires acknowledging the difference between verified facts, reasonable attributions, and pedagogical inventions. Too many textbooks present fictional scenarios alongside real research with no visible distinction, training students to treat all claims as equally authoritative. We prefer transparency.

If you are a student using this textbook and you discover that any Tier 1 source contains an error (wrong page number, incorrect edition, etc.), or if you can verify or refute any Tier 2 claim, we encourage you to contact the authors. Accuracy improves through community diligence.