 | 1999 |
|---|
| 49 |       | Andrew Koenig,
Barbara Moo:
Teaching Standard C++, Part 2.
JOOP 11(8): 64-67 (1999) |
| 48 | | Andrew Koenig,
Barbara Moo:
Teaching Standard C++, Part 3.
JOOP 11(9): 59-63 (1999) |
| 1998 |
|---|
| 47 | | Andrew Koenig:
A Quiet Revolution.
JOOP 10(8): 10-13, 16 (1998) |
| 46 | | Andrew Koenig:
Report from Morristown.
JOOP 10(9): 5-8 (1998) |
| 45 | | Andrew Koenig:
A Programming Revolution in Languages Founded on Object Logic.
JOOP 11(1): 13-16 (1998) |
| 44 | | Andrew Koenig:
Is Abstraction Good?
JOOP 11(2): 66-69 (1998) |
| 43 | | Andrew Koenig:
Simulating Dynamic Types in C++, Part 1.
JOOP 11(3): 76-78, 80 (1998) |
| 42 | | Andrew Koenig:
Simulating Dynamic Types in C++, Part 2.
JOOP 11(4): 63-67 (1998) |
| 41 | | Andrew Koenig:
Why Are Vectors Efficient?
JOOP 11(5): 71-75 (1998) |
| 40 | | Andrew Koenig:
A Standard C++ Appetizer.
JOOP 11(6): 85-87 (1998) |
| 39 | | Andrew Koenig,
Barbara Moo:
Teaching Standard C++.
JOOP 11(7): 11-17 (1998) |
| 1997 |
|---|
| 38 | | Andrew Koenig:
C++ in the Classroom: A Look Forward.
JOOP 10(1): 59-61 (1997) |
| 37 | | Andrew Koenig:
Turning an Interface Inside out.
JOOP 10(2): 56-58 (1997) |
| 36 | | Andrew Koenig:
Which Container Should we Teach First?
JOOP 10(3): 10-12 (1997) |
| 35 | | Andrew Koenig:
A ``++decade'' of C++.
JOOP 10(4): 20-23, 34 (1997) |
| 34 | | Andrew Koenig:
Inheritance and Abbreviations.
JOOP 10(5): 6-9, 21 (1997) |
| 33 | | Andrew Koenig:
Report from London.
JOOP 10(6): 11-16 (1997) |
| 32 | | Andrew Koenig:
Compile-Time Type Computation.
JOOP 10(7): 11-14 (1997) |
| 31 | | Andrew Koenig:
The Importance - and Hazards - of Performance Measurement.
JOOP 9(8): 58-60 (1997) |
| 30 | | Andrew Koenig:
Iterator Iterators and Temporal Sequences.
JOOP 9(9): 66-67, 71 (1997) |
| 1996 |
|---|
| 29 | | Andrew Koenig:
Function Adaptors.
JOOP 8(8): 51-53 (1996) |
| 28 | | Andrew Koenig:
Compatibility vs. Progress.
JOOP 8(9): 48-50 (1996) |
| 27 | | Andrew Koenig:
Generic Input Iterators.
JOOP 9(1): 72-75 (1996) |
| 26 | | Andrew Koenig:
Memory Allocation and C Compatibility.
JOOP 9(2): 42-43, 54 (1996) |
| 25 | | Andrew Koenig:
C++ as a First Language.
JOOP 9(3): 47-49 (1996) |
| 24 | | Andrew Koenig:
Design, Behavior, and Expectation.
JOOP 9(4): 79-81 (1996) |
| 23 | | Andrew Koenig:
Interface and Initiative.
JOOP 9(5): 64-67 (1996) |
| 22 | | Andrew Koenig:
Arithmetic Sequence Iterators.
JOOP 9(6): 38-39, 92 (1996) |
| 21 | | Andrew Koenig:
Garbage Collection in C++: No Panacea, but Useful.
JOOP 9(7): 55-57 (1996) |
| 1995 |
|---|
| 20 | | Andrew Koenig:
Introduction to Iterator Adaptors.
JOOP 7(8): 66-68 (1995) |
| 19 | | Andrew Koenig:
Polymorphic Reflections.
JOOP 7(9): 65-67, 80 (1995) |
| 18 | | Andrew Koenig:
Patterns and Antipatterns.
JOOP 8(1): 46-48 (1995) |
| 17 | | Andrew Koenig:
Is Programming Like Photography?
JOOP 8(2): 73-75 (1995) |
| 16 | | Andrew Koenig:
Wrapping up the Standard.
JOOP 8(3): 60-62 (1995) |
| 15 | | Andrew Koenig:
An Example of Language-Sensitive Design.
JOOP 8(4): 56-58, 61 (1995) |
| 14 | | Andrew Koenig:
Function Objects, Templates, and Inheritance.
JOOP 8(5): 65-68, 84 (1995) |
| 13 | | Andrew Koenig:
Variations on a Handle Theme.
JOOP 8(6): 77-80 (1995) |
| 12 | | Andrew Koenig:
Another Handle Variation.
JOOP 8(7): 61-63 (1995) |
| 11 | | Andrew Koenig:
Idiomatic design.
OOPS Messenger 6(4): 14-19 (1995) |
| 10 | | Andrew Koenig,
Bjarne Stroustrup:
Foundations for Native C++ Styles
Softw., Pract. Exper. 25(S4): S4/45-S4/86 (1995) |
| 1994 |
|---|
| 9 | | Andrew Koenig:
When to Write Buggy Programs.
JOOP 7(1): 80-82 (1994) |
| 8 | | Andrew Koenig:
Libraries in Everyday Use.
JOOP 7(2): 68-72, 80 (1994) |
| 7 | | Andrew Koenig:
Templates and Generic Algorithms.
JOOP 7(3): 45-47 (1994) |
| 6 | | Andrew Koenig:
Surrogate Classes in C++.
JOOP 7(4): 71-72, 80 (1994) |
| 5 | | Andrew Koenig:
Generic Iterators.
JOOP 7(5): 69-72 (1994) |
| 4 | | Andrew Koenig:
Thoughts on Abstraction.
JOOP 7(6): 68-70 (1994) |
| 1992 |
|---|
| 3 | | Andrew Koenig:
Space-Efficient Trees in C++.
C++ Conference 1992: 117-130 |
| 1991 |
|---|
| 2 | | Andrew Koenig,
Thomas A. Cargill,
Keith E. Gorlen,
Robert B. Murray,
Michael Vilot:
How Useful is Multiple Inheritance in C++?
C++ Conference 1991: 81-84 |
| 1990 |
|---|
| 1 | | Andrew Koenig,
Bjarne Stroustrup:
Exception Handling for C++.
C++ Conference 1990: 149-176 |
