A Conversation with Anders Hejlsberg (July 2003) -- Anders Hejlsberg discusses many aspects of C# and .NET.

• Part I: The C# Design Process -- the process used by the team that designed C#, and the relative merits of usability studies and good taste in language design.
• Part II: The Trouble with Checked Exceptions -- versionability and scalability issues with checked exceptions.
• Part III: Delegates, Components, and Simplexity -- delegates and C#'s first class treatment of component concepts.
• Part IV: Versioning, Virtual, and Override -- why C# instance methods are non-virtual by default and why programmers must explicitly indicate an override.

A Conversation with James Gosling (May 2003) -- James Gosling discusses many aspects of programming.

• Part I: Analyze this! -- How James Gosling's current research project, code-named Jackpot, builds annotated parse trees for programs that can help you analyze, visualize, and refactor your program.
• Part II: Failure and Exceptions -- How to build solid apps, organize your catch clauses, scale checked exceptions, and deal with failure.

A Conversation with Elliotte Rusty Harold (March 2003) -- Elliotte Rusty Harold discusses the strengths and weaknesses of the various XML processing APIs for Java, the design problems with existing APIs, and the design philosophy behind XOM.

• Part I: What's Wrong with XML APIs -- the five styles of XML APIs, and the problems with data-binding APIs.
• Part II: The Good, the Bad, and the DOM -- the problems with the DOM API, and design lessons learned from DOM.
• Part III: A Design Review of JDOM -- the problems with the JDOM API, which are mostly general design issues for any Java API.
• Part IV: Lessons Learned from JDOM -- design lessons learned from the JDOM API.
• Part V: Design Principles and XOM -- the API design principles that guided the design of the XOM API.
• Part VI: Air Bags and Other Design Principles -- API design principles including enforcement of invariants, information hiding for simplicity, and not using assertions for air bags.
• Part VII: Design by Dictatorship, Examples, and Tests -- design lessons learned from the JDOM API.

A Conversation with Vienna Teng (February 2003) -- Vienna Teng discusses the creative process and dream chasing.

• Part I: How Vienna Escaped the Cubicle -- How Vienna Teng, a 24 year old Java programmer at Cisco, landed a record contract, quit her day job to pursue her passion in music, and before long ended up on the Dave Letterman show.

A Conversation with Bruce Eckel (August 2002) -- Bruce Eckel explains why he loves Python.

• Part I: Python and the Programmer -- Why Bruce feels Python is "about him," how minimizing clutter improves productivity, and the relationship between backwards compatibility and programmer pain.
• Part II: The Zen of Python -- Why Bruce prefers Python's valuing programmer productivity over program performance, Python's you-want-it-you-can-have-it attitude, and Python's zen-like learning curve.

A Conversation with Andy Hunt and Dave Thomas (January 2003) --

Pragmatic Programmers Andy Hunt and Dave Thomas discuss software development:

• Part I. Don't Live with Broken Windows -- the importance of software craftsmanship and the importance of staying on top of the small problems in your projects.
• Part II. Orthogonality and the DRY Principle -- the importance of keeping your system orthogonal, and the real meaning the DRY, or Don't Repeat Yourself, principle.
• Part III. Good Enough Software -- the myth of bug-free software, the importance of specifying level of quality as a system requirement, and the need for every team member to inject quality throughout the development cycle.
• Part IV. Abstraction and Detail -- an approach to design in which details are pulled out of the code and stored as metadata.
• Part V. Building Adaptable Systems -- reversible design decisions, the cost of change curve, going beyond the requirements, and making systems configurable.
• Part VI. Programming Close to the Domain -- the benefit of programming in a language close to the business domain.
• Part VII. Programming is Gardening, not Engineering -- a gardening metaphor for software development, the reasons coding is not mechanical, and the stratification of development jobs.
• Part VIII. Tracer Bullets and Prototypes -- the importance of getting feedback during development by firing tracer bullets and building prototypes.
• Part IX. Programming Defensively -- the importance of programming defensively against your own and other's mistakes, of crashing near the cause, and understanding the proper use assertions.
• Part X. Plain Text and XML -- the value of storing persistent data in plain text and the ways they feel XML is being misused.

A Conversation with Rob Gingell (November 2002) -- Frank Sommers interviews Sun Microsystems' fellow and chief engineer Rob Gingell, the chair of the Java Community Process (JCP), about the JCP.

• Part I: Standards and Innovation -- open source licensing, source and binary compatibility, binary standards, and the JCP.
• Part II: Froth and Compatibility -- the pressures on vendors to both create froth—to add value on top of standards—and maintain compatibility in a multi-vendor industry.

A Conversation with Guido van Rossum (July 2002) -- Guido van Rossum, the creator of Python, gives insights into Python's design goals, the source of Python programmer productivity, the implications of weak typing, and more.

• Part I: The Origins of Python -- Python's history, major influences, and design goals.
• Part II: Python's Design Goals -- how Python was originally intended to "bridge the gap between the shell and C," and how it eventually became used on large scale applications.
• Part III: Programming at Python Speed -- the source of Python's famed programmer productivity and the joys of exploring new territory with code.
• Part IV: Contracts in Python -- the nature of contracts in a runtime typed programming language such as Python.
• Part V: Strong versus Weak Typing -- the robustness of systems built with strongly and weakly typed languages, the value of testing.
• Part VI: Designing with the Python Community -- the importance of "pythonic" API design, the usefulness of intuiting performance, the value of experience and community feedback in design decisions, and the process of deciding how to evolve Python's standard library.

A Conversation with Scott Meyers (August 2002) -- Scott Meyers, C++ expert and author of numerous books including Effective C++, talks with Bill Venners about many topics of object-oriented design, including the use of multiple inheritance in light of Java's interface, designing minimal and complete interfaces, public data members and contracts, and the utility of const.

• Part I: Multiple Inheritance and Interfaces -- how Meyer's view of multiple inheritance has changed with time, the C++ community's take on Java's interface, and a schism of focus between the C++ and other prominent development communities.
• Part II: Designing Contracts and Interfaces -- interface contracts, private data, and designing minimal and complete interfaces.
• Part III: Meaningful Programming -- the importance of saying what you mean and understanding what you say, the three fundamental relationships between classes, and the difference between virtual and non-virtual functions.
• Part IV: Const, RTTI, and Efficiency -- the utility of const, the appropriate time to use RTTI, a good attitude about efficiency, and Scott Meyers' current quest for general programming principles.

A Conversation with Martin Fowler (August 2002) -- Martin Fowler, chief scientist at Thoughtworks, Inc. and author of numerous books on software design and process, discusses refactoring, design, testing, and extreme programming.

• Part I: Refactoring with Martin Fowler -- the business case for refactoring and testing, and the interplay between refactoring, design, and reliability.
• Part II: Design Principles and Code Ownership -- design principles of avoiding duplication, separating presentation and domain logic, being explicit, and describes how refactoring depends on code ownership.
• Part III: Evolutionary Design -- planned and evolutionary design, refactoring bad smells in code, and how good design can help you program faster.
• Part IV: Flexibility and Complexity -- how to combat design decay, the cost of flexibility and reusability, four criteria for a simple system, and test-first design of interfaces.
• Part V: Test-Driven Development -- the unhurried quality of test-first design and monological thinking, and the difference between unit and functional testing.
• Part VI: Tuning Performance and Process -- balancing maintainability and efficiency, creating tunable software, the role of patterns, and the Agile Software Manifesto.

A Conversation with Sean Neville (August 2002) -- The former lead architect of Macromedia's JRun application server discusses JRun's object clustering architecture, and how Jini facilitated its implementation.

• Part I: Clustering J2EE with Jini -- the object clustering architecture desired for the app server, and how Jini facilitated it.
• Part II: Dynamic Enterprise Systems and Jini -- the messaging approach used to implement remote method invocations in JRun, and situations in which enterprise developers may find Jini useful.

A Conversation with Ken Arnold (April 2002) -- The original lead architect of JavaSpaces discusses design in general, and the design of JavaSpaces in particular.

• Part I: Perfection and Simplicity -- the myth of "the perfect design" and ways to achieve design simplicity
• Part II: Taste and Aesthetics -- the role of taste in design and the importance of designing with the user in mind
• Part III: Designing Distributed Systems -- designing for failure, using transactions and idempotency, and avoiding state
• Part IV: Sway with JavaSpaces -- loose coupling in JavaSpace-based systems, why fields in entries are public, RPCs to nowhere, and building systems that sway with failure
• Part V: JavaSpaces: Data, Decoupling, and Iteration -- the data-driven nature of JavaSpaces, how JavaSpaces facilitates decoupling, and why iteration isn't supported in the JavaSpace interface
• Part VI: Java Design Issues -- whether to prohibit subclassing, whether to use Cloneable or copy constructors, and when to use marker interfaces

A Conversation with Bob Scheifler (April 2002) -- The lead architect of Jini's Davis project discusses Jini Security.

• Part I: Jini Security -- the need for security in Jini and the special security considerations of dynamically downloaded code.
• Part II: Proxy Trust -- the mechanisms used to determine whether a downloaded proxy should be trusted.
• Part III: Object Integrity -- the mechanisms used to achieve object integrity.
• Part IV: Security Constraints -- security constraints and the RemoteSecurity interface.
• Part V: Dynamic Permission Grants -- how permissions are granted dynamically to proxies.
• Part VI: Jini Extensible Remote Invocation -- a new implementation of the RMI programming model.

A Conversation with James Gosling (February 2002) -- Java's creator discusses semantic models, mobile behavior, abstraction versus vagueness, testing, and repetitive stress injury.

A Conversation with Josh Bloch (December 2001) -- The author of Effective Java talks about design.

A Conversation with Jim Waldo (November 2001) -- Jini's chief architect discusses mobility, change, reliability, enterprise distributed computing, and more.

A Conversation with James Gosling (May 2001) -- Java's creator discusses inheritance and composition, JSPs and Servlets, community design processes, and more.

A Conversation with James Gosling (May 2000) -- Java's creator speaks on developer tools, the realtime JVM, mobile objects, strict interfaces, and more.

A Conversation with James Gosling (May 1999) -- Java's creator speaks on interfaces and protocols, servers and services, Jini, Java in the enterprise, and more.