Andrew Koenig is a former AT&T researcher and programmer. He is the author of C Traps and Pitfalls, co-author (with Barbara Moo) of Accelerated C++ & Ruminations on C++, and his name is associated with argument-dependent name lookup, also known as "Koenig lookup". He served as the Project Editor of the ISO/ANSI standards committee for C++, has authored over 150 papers on C++, and is listed as inventor on four patents.
The first book he authored, in 1987, C Traps and Pitfalls, had been motivated by his prior paper and work on a different computer language, PL/I. In 1977, while a staff member working at Columbia University, Koenig presented a paper called "PL/I Traps and Pitfalls" at a SHARE meeting in Washington, DC.
Koenig has a BS and MS degree from Columbia University in New York. He was a prominent member of the Columbia University Center for Computing Activities (CUCCA). He wrote the first e-mail program used at the university.
User Authentication System Employing Encryption Functions, #4,590,470. "Combines public-key random challenge-response authentication with hiding the authentication algorithm in a device that makes available only the algorithm's inputs and outputs. That secures the session against eavesdropping and replay and requires no secret information on the host."
Storing trees in navigable form, #5,530,957. "A technique for storing trees (such as representations of source programs in a programming environment) that completely eliminates space overhead normally associated with storing pointers, while still permitting common navigational operations with reasonable time efficiency."
Method and apparatus for parsing source code using prefix analysis, #5,812,853, "A technique for speeding up preliminary processing, such as macro preprocessing, in a compiler by remembering useful prefix strings of the input program in a tree-like data structure and keying those strings to remembered states of the compiler."
Method and apparatus for paging alternate users, #6,057,782, "The idea of allowing paging systems that support acknowledgments to reorder their list of destinations for future pages based on the acknowledgment or lack thereof on previous pages."
Andrew Koenig, Barbara Moo: Teaching Standard C++, Part 2. Journal of Object Oriented Programming (JOOP) 11(8): 64-67 (1999)
Andrew Koenig, Barbara Moo: Teaching Standard C++, Part 3. JOOP 11(9): 59-63 (1999)
1998
A Quiet Revolution. JOOP 10(8): 10-13, 16 (1998)
Report from Morristown. JOOP 10(9): 5-8 (1998)
A Programming Revolution in Languages Founded on Object Logic. JOOP 11(1): 13-16 (1998)
Is Abstraction Good? JOOP 11(2): 66-69 (1998)
Simulating Dynamic Types in C++, Part 1. JOOP 11(3): 76-78, 80 (1998)
Simulating Dynamic Types in C++, Part 2. JOOP 11(4): 63-67 (1998)
Why Are Vectors Efficient? JOOP 11(5): 71-75 (1998)
A Standard C++ Appetizer. JOOP 11(6): 85-87 (1998)
Andrew Koenig, Barbara Moo: Teaching Standard C++. JOOP 11(7): 11-17 (1998)
1997
C++ in the Classroom: A Look Forward. JOOP 10(1): 59-61 (1997)
Turning an Interface Inside out. JOOP 10(2): 56-58 (1997)
Which Container Should we Teach First? JOOP 10(3): 10-12 (1997)
A ``++decade of C++. JOOP 10(4): 20-23, 34 (1997)
Inheritance and Abbreviations. JOOP 10(5): 6-9, 21 (1997)
Report from London. JOOP 10(6): 11-16 (1997)
Compile-Time Type Computation. JOOP 10(7): 11-14 (1997)
The Importance - and Hazards - of Performance Measurement. JOOP 9(8): 58-60 (1997)
Iterator Iterators and Temporal Sequences. JOOP 9(9): 66-67, 71 (1997)
1996
Idiomatic Design, invited talk for ACM OOPSLA'95; published in Post-conference Proceedings and reprinted in abridged form in CACM Vol. 39, No. 11, November, 1996.
Function Adaptors. JOOP 8(8): 51-53 (1996)
Compatibility vs. Progress. JOOP 8(9): 48-50 (1996)
Generic Input Iterators. JOOP 9(1): 72-75 (1996)
Memory Allocation and C Compatibility. JOOP 9(2): 42-43, 54 (1996)
C++ as a First Language. JOOP 9(3): 47-49 (1996)
Design, Behavior, and Expectation. JOOP 9(4): 79-81 (1996)
Andrew Koenig, Bjarne Stroustrup: Foundations for Native C++ Styles Softw., Pract. Exper. 25(S4): S4/45-S4/86 (1995)
1994
An anecdote about ML type inference, USENIX Very High Level Languages Symposium, October 1994, Santa Fe
When to Write Buggy Programs. JOOP 7(1): 80-82 (1994)
Libraries in Everyday Use. JOOP 7(2): 68-72, 80 (1994)
Templates and Generic Algorithms. JOOP 7(3): 45-47 (1994)
Surrogate Classes in C++. JOOP 7(4): 71-72, 80 (1994)
Generic Iterators. JOOP 7(5): 69-72 (1994)
Thoughts on Abstraction. JOOP 7(6): 68-70 (1994)
1992
Space-Efficient Trees in C++. C++ Conference 1992: 117-130
1991
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
Andrew Koenig, Bjarne Stroustrup: Exception Handling for C++. C++ Conference 1990: 149-176
1988
Associative arrays in C++, Summer 1988 Usenix Conference (pp. 173-186), San Francisco
1986
The Snocone Programming Language, Bell Labs Computing Science Technical Report #124, August 19, 1986
