Articles in the Journal of Object-Oriented Programming
Vol. 1, no. 1: What is C++, Anyway?
Vol. 1, no. 2: Why I use C++
Vol. 1, no. 3: An example of dynamic binding in C++
Vol. 1, no. 4: Living in the Real World
Vol. 1, no. 5: How virtual functions work
Vol. 1, no. 6: References in C++
Vol. 2, no. 1: Why I work on C++
Vol. 2, no. 2: Objects, values, and assignment
Vol. 2, no. 3: Analysis of a demonstration
Vol. 2, no. 4: What are friends for?
Vol. 2, no. 5: Looking around
Vol. 2, no. 6: What's new?
Vol. 3, no. 1: Letter from a newcomer
Vol. 3, no. 2: An exceptional ideal
Vol. 3, no. 3: An object lesson in library interface design
Vol. 3, no. 4: Frequent questions
Vol. 3, no. 5: Bearing the standard: how to survive an X3J16 meeting
Vol. 4, no. 2: Introducing templates
Vol. 4, no. 3: Library design is language design
Vol. 4, no. 4: Language design is library design
Vol. 4, no. 5: Templates as interfaces
Vol. 4, no. 6: Analysis of a proposed C++ feature
Vol. 4, no. 7: Understanding constructor initializers in C++
Vol. 4, no. 8: Report from Phoenix
Vol. 4, no. 9: Designing a C++ container class
Vol. 5, no. 1: A proposal regarding invisible logic for object oriented languages
Vol. 5, no. 3: Virtual function return types
Vol. 5, no. 4: Accessing C++ container elements
Vol. 5, no. 5: What's in a name?
Vol. 5, no. 6: Understanding C++ overloaded functions
Vol. 5, no. 7: Classes that keep track of themselves
Vol. 5, no. 8: Analysis of a classroom exercise, part 1
Vol. 5, no. 9: Analysis of a classroom exercise, part 2: a straightforward solution
Vol. 6, no. 1: Analysis of a classroom exercise, part 3: a flexible solution
Vol. 6, no. 2: Iterators and use counts
Vol. 6, no. 3: Allocating C++ objects in clusters
Vol. 6, no. 4: From Lund to Cambridge
Vol. 6, no. 5: What do you do after you say ``Hello world''?
Vol. 6, no. 6: History isn't over quite yet
Vol. 6, no. 7: Wrapping up the standard
Vol. 6, no. 8: Simplicity through complexity
Vol. 6, no. 9: Designing a Boolean data type
Vol. 7, no. 1: When to write buggy programs
Vol. 7, no. 2: Libraries in everyday use
Vol. 7, no. 3: Templates and generic algorithms
Vol. 7, no. 4: Surrogate classes in C++
Vol. 7, no. 5: Generic iterators
Vol. 7, no. 6: Thoughts on abstraction
Vol. 7, no. 7: File iterators
Vol. 7, no. 8: Introduction to iterator adaptors
Vol. 7, no. 9: Polymorphic reflections
Vol. 8, no. 1: Patterns and antipatterns
Vol. 8, no. 2: Is programming like photography?
Vol. 8, no. 3: Wrapping up the standard
Vol. 8, no. 4: An example of language-sensitive design
Vol. 8, no. 5: Function objects, templates, and inheritance
Vol. 8, no. 6: Variations on a handle theme
Vol. 8, no. 7: Another handle variation
Vol. 8, no. 8: Function adaptors
Vol. 8, no. 9: Compatibility vs. progress
Vol. 9, no. 1: Generic input iterators
Vol. 9, no. 2: Memory allocation and C compatibility
Vol. 9, no. 3: C++ as a first language
Vol. 9, no. 4: Design, behavior, and expectation
Vol. 9, no. 5: Interface and initiative
Vol. 9, no. 6: Arithmetic sequence iterators
Vol. 9, no. 7: Garbage collection in C++: no panacea, but useful
Vol. 9, no. 8: The importance--and hazards--of performance measurement
Vol. 9, no. 9: Iterator iterators and temporal sequences
Vol. 10, no. 1: C++ in the classroom--a look forward
Vol. 10, no. 2: Turning an interface inside out
Vol. 10, no. 3: Which container should we teach first?
Vol. 10, no. 4: A ++decade of C++
Vol. 10, no. 5: Inheritance and abbreviations
Vol. 10, no. 6: Report from London
Vol. 10, no. 7: Compile-time type computation
Vol. 10, no. 8: A quiet revolution
Vol. 10, no. 9: Report from Morristown
Vol. 11, no. 1: A programming revolution in languages founded on object logic
Vol. 11, no. 2: Is abstraction good?
Vol. 11, no. 3: Simulating dynamic types in C++, part 1
Vol. 11, no. 4: Simulating dynamic types in C++, part 2
Vol. 11, no. 5: Why are vectors efficient?
Vol. 11, no. 6: A standard C++ appetizer
Vol. 11, no. 7: Teaching standard C++
Vol. 11, no. 8: Teaching standard C++, part 2
Vol. 11, no. 9: Teaching standard C++, part 3
Vol. 12, no. 1: Teaching standard C++, part 4
Vol. 12, no. 2: the considered questionable
Vol. 12, no. 3: Report from Dublin
Vol. 12, no. 4: Evolving an example, part 1
Vol. 12, no. 5: Evolving an example, part 2
Vol. 12, no. 6: Performance: myths, measurements, and morals; Part 1: myths
Vol. 12, no. 7: Performance: myths, measurements, and morals; Part 2: Even easy measurements are hard
Vol. 12, no. 8: Performance: myths, measurements, and morals; Part 3: Quadratic behavior will get you if you don't watch out!
Vol. 12, no. 9: Performance: myths, measurements, and morals; Part 4: How might we speed up a simple program?
Vol. 13, no. 1: Performance: myths, measurements, and morals; Part 5: How not to measure execution time
Vol. 13, no. 2: Performance: myths, measurements, and morals; Part 6: Useful measurements\(emfinally!
Vol. 13, no. 3: Performance: myths, measurements, and morals; Part 7: Detailed measurements of a small program