Like this article? We recommend

Danny Kalev: What's the design philosophy of Go? Which drawbacks of other programming languages did you try to avoid? Which programming languages inspired you?

Rob Pike: The goal was comprehensibility. The features of Go are intended to be orthogonal so that when they're combined, they interact in clear, predictable ways. Once you understand the building blocks (methods, interfaces, concurrency, and so on), you shouldn't need help from the reference manual to write interesting code.

Some languages informed the design; many ideas were borrowed from existing languages. But the inspiration came from our collective experience as programmers, writing real software.

Danny: What difficulties are associated with designing a programming language from scratch, as compared to using an existing programming language as a platform for extensions and modifications?

Rob: It's a lot of fun, which is why so many languages are out there. The trick is to control the urge to put in every feature that comes to mind. It's also important to worry more about semantics than syntax.

Robert Griesemer, one of the original Go troika, has observed that the language turned out much better than a language he would have designed himself. I agree with that sentiment—it's better than a language I would have designed myself. Ken Thompson, Robert, and I all brought different perspectives and backgrounds to the discussions, even as we shared a desire to solve common problems.

Consensus drove the design. Nothing went into the language until all three of us agreed that it was right. This meant that some features didn't get resolved until after a year or more of discussion. A bad feature is much harder to take out than a good feature is to put in.

Danny: Who are the target users of Go? For example, is Go suitable for real-time/embedded systems and system programming? Or is it likely to attract mostly web application developers?

Rob: Our target community was ourselves, of course, and the broader systems-programming community inside Google. As the language developed, we were pleased and a little surprised to find it suitable for general-purpose programming. Go could be used for real-time and embedded work, although some more development of the libraries would likely be necessary. It's useful today for many systems jobs. It's been used for everything from back-end server software and high-volume web servers to interactive games. It's too early to say what community, if any, will find Go to be the right language for their problems, but there are lots of possibilities.

Danny: What can experienced C++ programmers expect from Go? What are the main advantages that they'll find in it? What might deter them?

Rob: Go is more unusual than you might first realize. The combination of concurrency, its unusual type system, full closures, and reflection make it surprisingly expressive. C++ programmers who give Go a fair chance may be surprised at its power. Go is a much simpler language, but it captures a lot of the essentials. Programmers may notice that some of their favorite features are missing, but they may also find that lack more than compensated by other properties of the language.

Go is also a lot lighter on the page. Although Go's syntax isn't radically different from C's in most respects, we tried to simplify and regularize it. Initialization expressions imply the type in declarations, which means that type names are rare outside function signatures, for example. And there are far fewer semicolons. Also, as in Java, in Go the package system means that you only need to declare things once, not in the header and in the implementation. These creature comforts add up.

Go has converted a number of C++ programmers. We were surprised that it also appeals to a number of Python programmers, who find it to be nice to use but much more efficient—and statically typed.

Danny: Go supports only interface inheritance, but it doesn't have proper inheritance. Will inheritance be added in the future, or does this design decision express disappointment with traditional object-oriented programming concepts, particularly inheritance?

Rob: Go does have proper inheritance, although it's different from inheritance in C++. C++ inheritance, which is based on subtype polymorphism, combines classes, virtual functions, visibility of members, and so on into a powerful but intricate and subtle mix.

Go takes a different approach. Rather than subtype polymorphism, Go has embedded anonymous fields (embedding for short). Embedding is a simple concept orthogonal to the other elements of the type system, such as structures and interfaces. It injects fields and methods of an existing type into another type. (In fact, there is no explicit concept of subtype in Go). Embedding is a building block that can be used to create the effect of inheritance, but also of forwarding, of prototype-based type systems, and more.

Go is object-oriented, even though it doesn't have the notion of a class. The type system is more general. Any type—even basic types such as integers and strings—can have methods. This allows inheritance and other object-oriented techniques to apply more broadly than with classes alone. For instance, Go's formatted printing library, package fmt, uses interfaces and methods to provide a way to use a printf-like API to print any value, ranging from basic types to arbitrary user-defined objects, with perfect type safety.

Danny: It's no secret that C++ is an old programming language. However, its main benefit today is its Standard Library of generic algorithms and containers. Migrating from C++ to any other programming language means giving up this benefit. Will Go offer its own library of generic containers and algorithms in the future?

Rob: C++ is large enough that different users see it differently. I agree that for some the STL is important; for others, it's operator overloading, or RAII, or simply having an object-oriented language that runs close to the metal. And of course many programmers don't use C++ at all.

As far as Go and generics are concerned, we're actively trying to find a design that sits well with the other features of the language. It's not easy in any language, I suspect. If—and only if—we find the right design, Go will acquire generics, and then likely a generic library of some kind. Meanwhile, we've found that, although generics would be nice, they're not as vital to Go as they might be in other languages. The built-in string, slice, and map types cover many of the needs addressed by the STL in C++. Not all, of course, but a significant amount.

Danny: In a recent interview for DevX, you mentioned the complexity of industrial programming languages such as Java and C++. Can you pinpoint the specific problems you were facing while using C++ in industrial projects? How does Go avert these problems?

Rob: The starting point was long compile times—for some of our big software at Google, build times can be unreasonably long, even with our large distributed compilation clusters. The dependency management (or lack thereof) in C and C++ results in far too much code going through the compiler. You might say that Go was conceived while waiting for a big compilation.

C++ header files, which are just a mechanism for source code inclusion, make dependencies hard to manage; bloat is almost inevitable. Go has a strong package system that compiles all dependencies out to a single level—which not only speeds up compilation, but forces a cleaner dependency hierarchy.

C++ is very powerful, but also very low-level in many respects. Every time I compile a .cc file, #include <string> teaches the compiler about strings. Why can't the language just have strings?

We also thought that it was important to provide language-level support for concurrency. Multiprocessors are easier to program when the language knows about stack and memory management, and when it provides messaging and synchronization primitives.

Go automates a lot of the fussy details that C and C++ (and to a lesser extent, Java) make explicit. This makes it a different kind of language. Go takes a strong stand about issues such as memory management and concurrency, issues that C++ leaves to the programmer.

Go isn't intended to replace Java, C++, or any other language. It was designed in response to some of the problems we encountered while writing large systems for modern hardware. The result seems to work well as a general-purpose language, one that many programmers have found delightful to use.

Danny: The evolution of Java, C#, and several other new programming languages suggests that they start out as simple and easy to learn, but this simplicity is illusory. After a maturation process that takes about 10 years, they all become too complex to learn and use, carrying around excess baggage of deprecated APIs and obsolete features. How can you ensure that Go wouldn't undergo a similar process?

Rob: That's a very good question, and we've thought about it a lot. There's no real answer except to say that time will tell, and we'll try very hard to keep the language and the environment clean. Perhaps the best defense is resistance to features that don't fit cleanly into the language and libraries.

Danny: Java, C#, Objective C, and now Go are all proprietary languages whose design and evolution is steered by a commercial company with interests that don't necessarily coincide with those of the programmers using these languages. The outcry over Apple's iPhone 4.0 OS developer license is a good example of such a conflict. What were your motives for choosing the proprietary language model? How much influence will users have on Go's design?

Rob: Go isn't proprietary—it's completely an open source project. All of the development of Go is done in the open, in a public source-code repository and using public mailing lists. Like any other source of good ideas, users have influence (subject to the goals of the language). Go was only launched a few months ago, yet we have over a hundred contributors to the project—and that number continues to grow. For instance, the FreeBSD and Windows ports of Go were done entirely by contributors outside Google.

Danny: Is the name "Go" final? My main concern is that search engines (including Google's, of course) will have a hard time distinguishing between Go-related web pages and the billions of occurrences of the English verb go.

Rob: Search engines are good at context, and with context the name Go (like the names C, Java, and Ruby, and many other programming language names with alternate meanings) is distinguished just fine. Searches for programming-language topics and "go" find good results. For instance, the queries "go concurrency" and "go interfaces" grab lots of useful results. And even if I search for just "Go", the official Go site comes out near the top.

We like the name. It's short, evocative, and captures the spirit of the language.