Saks & Associates

Dan has written over 200 articles that have appeared in the following publications:

The C/C++ Users Journal (CUJ)
The C++ Report
Dr. Dobb's Journal (DDJ)
Embedded Systems Design (ESD), formerly Embedded Systems Programming (ESP); published on the web at embedded.com
Software Development Magazine (SD)
Windows™/DOS Developer's Journal (WDDJ), formerly Tech Specialist (TS).

Articles that appeared in Embedded Systems Programming (ESP) and Embedded Systems Design (ESD):

“How I Got Here”, ESP, Apr, 1998
“Placing Data into ROM”, ESP, May, 1998
“Placing const in Declarations”, ESP, Jun, 1998
“What const Really Means”, ESP, Aug, 1998
“Volatile Objects”, ESP, Sep, 1998
“Placing Data into ROM with Standard C”, ESP, Nov, 1998
“Static vs. Dynamic Initialization”, ESP, Dec, 1998
“const T vs. T const”, ESP, Feb, 1999
“Ensuring Static Initialization in C++”, ESP, Mar, 1999
“Function Name Overloading”, ESP, May, 1999
“Linking Function Calls”, ESP, Jun, 1999
“Function Signatures and Name Mangling”, ESP, Aug, 1999
“const and volatile in Parameter Types”, ESP, Sep, 1999
“Ensuring Static Initialization in C++”, ESP, Dec, 1999
“More on Overloading with const”, ESP, Jan, 2000
“Top-Level CV-Qualifiers in Function Parameters”, ESP, Feb, 2000
“Passing Parameters by Value with const”, ESP, Apr, 2000
“Is an Array Really Just a Pointer?”, ESP, Jun, 2000
“Arrays as Function Parameters”, ESP, Jul, 2000
“Numeric Literals”, ESP, Sep, 2000
“Character and String Literals”, ESP, Oct, 2000
“An Introduction to References”, ESP, Jan, 2001
“References and const”, ESP, Feb, 2001
“References vs. Pointers”, ESP, Apr, 2001
“A New Appreciation for Data Types”, ESP, May, 2001
“Lvalues and Rvalues”, ESP, Jun, 2001
“Non-modifiable Lvalues”, ESP, Jul, 2001
“Reference Initializations”, ESP, Aug, 2001
“Passing by Reference-to-const”, ESP, Oct, 2001
“Symbolic Constants”, ESP, Nov, 2001
“Enumeration Constants vs. Const Objects”, ESP, Dec, 2001
“Constant Objects and Constant Expressions”, ESP, Jan, 2002
“Symbolic Constant Expressions”, ESP, Feb, 2002
“As Precise as Possible”, ESP, Apr, 2002
“Evaluating Function Arguments”, ESP, May, 2002
“Sequence Points”, ESP, Jul, 2002
“Tag vs. Type Names”, ESP, Oct, 2002
“Enumerations as Counters”, ESP, Dec, 2002
“Well Behaved Enumerations”, ESP, Apr, 2003
“Enumerations Q & A”, ESP, May, 2003
“More on Enumerations”, ESP, Jul, 2003
“Enumerations with Noncontiguous Values”, ESP, Aug, 2003
“Moving to Higher Ground”, ESP, Oct, 2003
“Abstract Types Using C”, ESP, Nov, 2003
“Incomplete Types as Abstractions”, ESP, Dec, 2003
“C++ Classes as Abstractions”, ESP, Jan, 2004
“More About C++ Classes”, ESP, Apr, 2004
“How to Enforce Write-Only Access”, ESP, May, 2004
“Getting It Just Right”, ESP, Jul, 2004
“Mapping Memory”, ESP, Sep, 2004
“Mapping Memory Efficiently”, ESP, Nov, 2004
“More Ways to Map Memory”, ESP, Jan, 2005
“Sizing and Aligning Device Registers”, ESP, May, 2005
“Catching errors early with compile-time assertions”, ESP, Jul, 2005
“Use Volatile Judiciously”, ESP, Sep, 2005
“Place Volatile Accurately”, ESD, Nov, 2005
“Volatile as a Promise”, ESD, Jan, 2006
“Qualifiers in Multi-Level Pointers”, ESD, Mar, 2006
“Cast With Caution”, ESD, Jul, 2006
“Modeling Interrupt Vectors”, ESD, Sep, 2006
“Coming to terms with interrupt vectors and tables”, ESD, Nov, 2006
“Separated by a common vocabulary”, ESD, Jan, 2007
“Bail, return, jump, or . . . throw?”, ESD, Mar, 2007
“Throw and catch”, ESD, May, 2007
“Why size_t matters”, ESD, Jul, 2007
“Further insights into size_t”, ESD, Sep, 2007
“Standard C's pointer difference type”, ESD, Oct, 2007
“Scope Regions in C and C++”, ESD, Nov, 2007
“A Case Study in Portability”, ESD, Dec, 2007
“Storage Class Specifiers and Storage Duration”, ESD, Jan, 2008
“A sign of confusion”, ESD, Feb, 2008
“Linkage in C and C++”, ESD, Mar, 2008
“Ten Years After”, ESD, Apr, 2008
“The Yin and Yang of Dynamic Allocation”, ESD, May, 2008
“Into, but not out of, the void”, ESD, Jun, 2008
“Dynamic Allocation in C and C++”, ESD, Jul, 2008
“Enumerations are integers, except when they're not”, ESD, Aug, 2008
“Allocating objects vs allocating storage”, ESD, Sep, 2008
“Low-calorie enumerations”, ESD, Oct, 2008
“Better even at the lowest levels”, ESD, Nov, 2008
“In search of contrary evidence”, ESD, Dec, 2008
“Allocating arrays”, ESD, Jan, 2009
“Destroying everything in every path”, ESD, Feb, 2009
“Deallocating objects vs deallocating storage”, ESD, Mar, 2009
“Goodbye SD”, ESD, Apr, 2009
“Padding and rearranging structure members”, ESD, May, 2009
“Classes are structures, and then some”, ESD, Jun, 2009
“Access specifiers and class member allocation order”, ESD, Jul, 2009
“Poor reasons for rejecting C++”, ESD, Aug, 2009
“Allocating and deallocating arrays, in greater detail”, ESD, Sep, 2009
“Freestanding vs hosted implementations”, ESD, Oct, 2009
“Computing properly aligned pointer values”, ESD, Nov, 2009
“Science, anyone? Anyone?”, ESD, Dec, 2009
“Variations on a flexible array theme”, ESD, Feb, 2010
“Preventing dynamic allocation”, ESD, Mar, 2010
“Alternative models for memory-mapped devices”, ESD, May, 2010
“Memory-mapped devices as C++ classes”, ESD, Jun, 2010
“Compared to what?”, ESD, Aug, 2010
“Accessing memory-mapped classes directly”, ESD, Sep, 2010
“Bundled vs. unbundled monostate classes”, ESD, Nov, 2010
“Measuring instead of speculating”, ESD, Dec, 2010
“Demystifying constructors”, ESD, Jan, 2011
“Constructors and object definitions”, ESD, Mar, 2011
“Insights into member initialization”, ESD, May, 2011
“Using member initializers”, ESD, Jun, 2011
“Difficulties constructing memory-mapped objects”, ESD, Aug, 2011
“Calling constructors with placement new”, ESD, Sep, 2011
“Using member new to map devices”, ESD, Nov, 2011
“Judgment calls”, ESD, Dec, 2011
“Discriminated unions”, ESD, Mar, 2012
“Virtual Functions in C++”, ESD, Apr, 2012
“Unexpected trends”, ESD, May, 2012
“It's not the processor”, ESD, Jun, 2012
“Storage Layout for Polymorphic Objects”, ESD, Jul, 2012
“Virtual functions in C”, ESD, Aug, 2012
“Impure thoughts”, ESD, Sep, 2012
“Initializing Polymorphic Objects”, ESD, Oct, 2012
“Initializing derived polymorphic objects”, ESD, Nov, 2012
“Pure Virtual Functions”, ESD, Dec, 2012
“Implementing Pure Virtual Functions”, ESD, Jan, 2013
“Implementing a Derived Class Vtbl in C”, ESD, Feb, 2013
“Alternative Idioms for Inheritance in C”, ESD, Apr, 2013
“Reflections on virtual functions in C”, ESD, Jun, 2013
“Problems with inheritance by composition”, ESD, Jul, 2013

Articles that appeared in The C Users Journal or The C/C++ Users Journal (CUJ):

“Pointer Arithmetic at Segment Boundaries”, CUJ, Aug, 1989
“Portability in communications software”, CUJ, Nov, 1989
“Writing standard headers: The string functions”, CUJ, Jan, 1990
“Writing your own standard headers: <stdlib.h>, <stddef.h>, <stdarg.h>, and <limits.h>”, CUJ, Jan, 1990
“Writing Standard Headers 2”, CUJ, Mar, 1990
“Stepping Up to C++: Paving the Migration Path”, CUJ, Jan, 1991
“Stepping Up to C++: Writing Your First Class”, CUJ, Mar, 1991
“Stepping Up to C++: Your First Class”, CUJ, May, 1991
“Stepping Up to C++: Rewriting Modules as Classes”, CUJ, Jul, 1991
“Stepping Up to C++: Reference Types”, CUJ, Sep, 1991
“Stepping Up to C++: Function Name Overloading”, CUJ, Nov, 1991
“Stepping Up to C++: Operator Overloading”, CUJ, Jan, 1992
“Stepping Up to C++: Operator Overloading | part 2”, CUJ, Mar, 1992
“Stepping Up to C++: Operator Overloading | part 3”, CUJ, May, 1992
“Stepping Up to C++: Operator Overloading | part 4”, CUJ, Jul, 1992
“Stepping Up to C++: Initialization vs Assignment”, CUJ, Sep, 1992
“Stepping Up to C++: Dynamic Arrays”, CUJ, Nov, 1992
“Stepping Up to C++: The function operator[]”, CUJ, Jan, 1993
“Stepping Up to C++: Inheritance, part 1”, CUJ, Mar, 1993
“Stepping Up to C++: Inheritance, part 2”, CUJ, May, 1993
“Stepping Up to C++: Recent language extensions to C++”, CUJ, Jun, 1993
“Stepping Up to C++: Nested classes”, CUJ, Jul, 1993
“Stepping Up to C++: Looking up names”, CUJ, Aug, 1993
“Stepping Up to C++: Rewriting and reconsidering”, CUJ, Sep, 1993
“Stepping Up to C++: Temporary inconvenience, part 1”, CUJ, Oct, 1993
“Stepping Up to C++: Temporary inconvenience, part 2”, CUJ, Nov, 1993
“Stepping Up to C++: Virtual functions”, CUJ, Dec, 1993
“Stepping Up to C++: How virtual functions work”, CUJ, Jan, 1994
“Stepping Up to C++: Overloading and overriding”, CUJ, Feb, 1994
“Stepping Up to C++: The return types of virtual functions”, CUJ, Mar, 1994
“Stepping Up to C++: Compilation Firewalls, part 1”, CUJ, Apr, 1994
“Stepping Up to C++: Compilation Firewalls, part 2”, CUJ, May, 1994
“Stepping Up to C++: Designing generic container classes, part 1”, CUJ, Jun, 1994
“Stepping Up to C++: Designing generic container classes, part 2”, CUJ, Aug, 1994
“Stepping Up to C++: Designing generic container classes, part 3”, CUJ, Sep, 1994
“Stepping Up to C++: Designing generic container classes, part 4”, CUJ, Oct, 1994
“Stepping Up to C++: Designing generic container classes, part 5”, CUJ, Nov, 1994
“Stepping Up to C++: Designing generic container classes, part 6”, CUJ, Dec, 1994
“Stepping Up to C++: C++ at CD registration”, CUJ, Jan, 1995
“Stepping Up to C++: Minor enhancements to C++ as of CD registration”, CUJ, Feb, 1995
“Stepping Up to C++: More minor enhancements as of CD registration”, CUJ, Mar, 1995
“Stepping Up to C++: Mutable class members”, CUJ, Apr, 1995
“Stepping Up to C++: Even more minor enhancements”, CUJ, May, 1995
“Stepping Up to C++: Changes in the scope rules”, CUJ, May, 1995
“Stepping Up to C++: Other assorted changes, part 1”, CUJ, Jul, 1995
“Stepping Up to C++: Other assorted changes, part 2”, CUJ, Aug, 1995
“Stepping Up to C++: Other assorted changes, part 3”, CUJ, Sep, 1995
“Stepping Up to C++: Style and syntax”, CUJ, Oct, 1995
“The Column That Needs a Name: A sensible grammar notation”, CUJ, Nov, 1995
“The Column That Needs a Name: Understanding C++ declarations, part 1”, CUJ, Dec, 1995
“The Column That Needs a Name: Understanding C++ declarations, part 2”, CUJ, Jan, 1996
“The Column That Needs a Name: Parsing C++ declarations, part 1”, CUJ, Feb, 1996
“The Column That Needs a Name: Parsing C++ declarations, part 2”, CUJ, Mar, 1996
“The Column That Needs a Name: Recovering from parsing errors”, CUJ, Apr, 1996
“C++ Theory and Practice: Perspectives on grammars and parsers”, CUJ, May, 1996
“C++ Theory and Practice: Abstract declarators, part 1”, CUJ, Jun, 1996
“C++ Theory and Practice: Abstract declarators, part 2”, CUJ, Jul, 1996
“C++ Theory and Practice: Abstract declarators, part 3”, CUJ, Sep, 1996
“C++ Theory and Practice: Declarators, finale”, CUJ, Oct, 1996
“C++ Theory and Practice: const as a promise”, CUJ, Nov, 1996
“C++ Theory and Practice: Mixing const with Type Names”, CUJ, Dec, 1996
“C++ Theory and Practice: new and delete”, CUJ, Jan, 1997
“C++ Theory and Practice: C++ at its second CD ballot”, CUJ, Feb, 1997
“C++ Theory and Practice: Class-specific new and delete”, CUJ, Mar, 1997
“C++ Theory and Practice: Placement new”, CUJ, Apr, 1997
“C++ Theory and Practice: Placement delete”, CUJ, May, 1997
“C++ Theory and Practice: The syntax of new and delete-expressions, part 1”, CUJ, Jun, 1997
“C++ Theory and Practice: The syntax of new and delete-expressions, part 2”, CUJ, Jun, 1997
“C++ Theory and Practice: Maybe it wasn't such a good idea after all”, CUJ, Aug, 1997
“C++ Theory and Practice: Work-arounds for a mistake”, CUJ, Sep, 1997
“C++ Theory and Practice: Initializing and Copying Subobjects”, CUJ, Oct, 1997
“C++ Theory and Practice: Storage Classes and Linkage”, CUJ, Nov, 1997
“C++ Theory and Practice: Storage Classes and Language Linkage”, CUJ, Dec, 1997
“C++ Theory and Practice: An introduction to namespaces”, CUJ, Jan, 1998
“C++ Theory and Practice: Basing style on design principles”, CUJ, Mar, 1998
“C++ Theory and Practice: Partitioning with namespaces, part 1”, CUJ, Apr, 1998
“C++ Theory and Practice: Partitioning with namespaces, part 2”, CUJ, May, 1998
“C++ Theory and Practice: Partitioning with namespaces, part 3”, CUJ, Jun, 1998
“C++ Theory and Practice: Classes vs. namespaces”, CUJ, Jul, 1998
“C++ Theory and Practice: const in Parameter Lists”, CUJ, Sep, 1998
“C++ Theory and Practice: Partitioning with classes”, CUJ, Feb, 1999
“C++ Theory and Practice: Trimming excess fat”, CUJ, Mar, 1999
“C++ Theory and Practice: Thinking deeply”, CUJ, Apr, 1999
“C++ Theory and Practice: Thinking deeper”, CUJ, May, 1999
“C++ Theory and Practice: Thinking even deeper”, CUJ, Jul, 1999
“C++ Theory and Practice: Isolating design decisions, part 1”, CUJ, Aug, 1999
“C++ Theory and Practice: Isolating design decisions, part 2”, CUJ, Sep, 1999
“C++ Theory and Practice: Standard C++ as a high-level language?”, CUJ, Nov, 1999
“C++ Theory and Practice: Replacing Character Arrays with Strings 1”, CUJ, Jan, 2000
“C++ Theory and Practice: Replacing Character Arrays with Strings 2”, CUJ, Feb, 2000

Articles that appeared in The Journal of C Language Translation (JCLT):

“Standardizing C++: The First Year of Joint Meetings”, JCLT, Mar, 1993
“Standardizing C++: The Rest of 1992, Part 1”, JCLT, Jul, 1993
“Standardizing C++: The Rest of 1992, Part 2”, JCLT, Sep, 1993
“Standardizing C++: A Summary of the Committee's Technical Decisions”, JCLT, Sep, 1993

Articles that appeared in The C++ Report (CR):

“X3J16 Blesses Templates”, CR, Jul, 1990
“Exceptions Accepted”, CR, Nov, 1991
“Working on the Details”, CR, Mar, 1991
“X3J16 Meets WG21”, CR, Jun, 1991
“Works in Progress”, CR, Jun, 1991
“Two Years and Counting”, CR, Nov, 1991
“Scope and Name Lookup Rules”, CR, Mar, 1993
“The Return Type of Virtual Functions, and More”, CR, Mar, 1993
“Friends, Enumerations, and wchar_t”, CR, Jul, 1993

Articles that appeared in Software Development Magazine (SD):

“Execution Path: Say It In Code”, SD, Jul, 1993
“Execution Path: The Illusion of Simplicity”, SD, Aug, 1993
“Execution Path: Be Stingy with Data”, SD, Sep, 1993
“Say It In Code: But Comment If You Can't”, SD, Mar, 1994
“Say It In Code: Use Casts Sparingly”, SD, May, 1994
“Say It In Code: Enforce Logical Constness”, SD, Aug, 1994
“Say It In Code: Logical vs. Physical Types”, SD, Dec, 1994
“Say It In Code: Use const Member Functions”, SD, Jan, 1995
“Say It In Code: Portable Code is Better Code”, SD, Mar, 1995
“Say It In Code: Know Your Limits”, SD, Apr, 1995
“Say It In Code: Use Symbolic Expressions”, SD, Jun, 1995
“Say It In Code: More Symbolic Constant Expressions”, SD, Aug, 1995
“Say It In Code: Use Distinct Types for Distinct Purposes”, SD, Nov, 1995
“Say It In Code: Use Enumerations as Distinct Types”, SD, Dec, 1995
“Say It In Code: Looping Through Enumeration Values”, SD, Jan, 1996
“Say It In Code: A Favorable Image”, SD, Feb, 1996
“Say It In Code: Don't Disguise Character Codes”, SD, Apr, 1996
“Say It In Code: Avoid Implicit Declarations”, SD, Jun, 1996
“Say It In Code: Watch Out for Implicitly-Defined Functions”, SD, Aug, 1996
“Say It In Code: Turning Off Implicitly-Defined Functions”, SD, Feb, 1997

Articles that appeared in Tech Specialist (TS) or Windows™/DOS Developer's Journal (WDDJ):

“Extending the Power of Enumerations”, TS, Jul, 1990
“Finding Pointer Errors in Pascal”, TS, Aug, 1990
“Scanning and Converting Characters”, TS, Sep, 1990
“A Closer Look at Scanning”, TS, Nov, 1990
“All About Booleans”, TS, Jan, 1991
“Generic Functions in C and Pascal”, TS, Mar, 1991
“Just the Right Size”, TS, May, 1991
“Avoiding Unnecessary Preprocessing”, TS, Aug, 1991
“Using Built-In Set Types”, WDDJ, Dec, 1991
“More About Set Types”, WDDJ, Feb, 1992
“Compile-Time Genericity, Part 1”, WDDJ, Jun, 1992
“Compile-Time Genericity, Part 2”, WDDJ, Aug, 1992