Why Go?

Why Go

Historical Context

The Go programming language was developed at Google by Rob Pike, Robert Griesemer, and Ken Thompson. Rob Pike’s frustration with slow C++ compilation times led him to discuss the issue with Robert Griesemer, and Ken Thompson, working nearby, joined in. Their collaboration aimed to address the inefficiencies they faced with existing languages in Google’s large-scale environment.

Google’s software infrastructure, involving millions of lines of code and extensive use of C++, Java, and Python, required a language that balanced efficient compilation, fast execution, and ease of use. The existing languages fell short, prompting the team to create Go, which began as a 20% project in September 2007. By January 2008, work on the initial compiler started, and Go was open-sourced in November 2009. It reached its first stable release in March 2012.

Go was designed to improve software development efficiency and scalability at Google. It focused on addressing issues like slow compilation and cumbersome programming practices to enhance productivity and simplify management of large codebases. The language’s design emphasizes practical software engineering solutions over theoretical language research.

What Go Offers

Go, also known as Golang, stands out as an ideal choice for an enterprise programming language. These are a few of Go’s strong points, which makes it possible for this language to be chosen among enterprises:

• Simple and Easy to Learn: Go is designed to be straightforward. Its language features are minimal but effective, allowing developers to grasp and use them quickly. With just a few days of study, developers can become proficient in Go, making it easy to onboard new team members and maintain consistent coding standards across a team.
• Fast Compilation and Execution: One of Go’s biggest advantages is its fast compilation time. Unlike languages like C++ or Java, which can be slow to compile, Go produces binaries quickly. This means you spend less time waiting for your code to build and more time actually writing and improving it. Additionally, Go binaries run as fully optimized native code, meaning they start up fast and use CPU cores efficiently.
• Easy Maintenance and Collaboration: Go promotes code simplicity and clarity. Its standardized formatting and idiomatic ways of doing things make code easy to read and understand. This consistency reduces the cognitive load on developers, making it easier to review, debug, and collaborate on code. Go’s toolchain also supports automated code formatting and refactoring.
• No Runtime Dependencies: Go applications are standalone binaries, which means they don’t rely on external runtimes or libraries. This results in significantly smaller Docker images compared to languages like Java or Node.js. Deployment is also simplified because you don’t need to worry about installing additional software or managing runtime versions on your servers.
• Explicit Error Handling: Go takes a different approach to error handling by requiring developers to handle errors explicitly, making error management clear and predictable. This explicitness helps in identifying and addressing issues more effectively, making your applications more reliable.
• Cross-Platform Compatibility: Go’s runtime is lightweight and designed to be portable across various platforms, including macOS, Linux, and Windows.
• Modern Object-Oriented Features: Go embraces modern object-oriented principles while avoiding problematic features like inheritance. Instead, it supports composition, which provides better flexibility and scalability. This makes it easier for developers that are already familiar with OOP to switch to Go.
• Future-Proof: Go is designed with forward compatibility in mind. Software written in Go will continue to work with newer versions of the language, making it easier to upgrade and benefit from performance and security improvements over time.

In which scenarios can Go do better than Java

• When building small to medium-sized services: Because Go has no virtual machine, huge platform libraries, or a sophisticated garbage collector, and it compiles directly to machine code and supports static linking, Go has a very fast load times and very efficient resource usage. This makes it very easy to quickly spin up a new service with good performance. But when it comes to building large and complex services, Java is a better choice as it has more features and better support, along with a more “concrete” code structure.
• When building cloud-native, serverless applications: Because of Go’s simplicity and performance, a service written in Go takes minimal time to be spun up compared to those written in Java. This makes it ideal to use Go for building serverless applications, in which the cold start time is usually a problem worth considering.
• When doing extensive concurrent programming: Both Golang and Java provide support for concurrent programming. With Java, you can only manage green threads through JVM, which inevitably suffer from context switching and fixed stack size. Go, however, shines in this area with its goroutines and channels. Goroutines are essentially lightweight threads that are managed by the Go runtime, allowing developers to write highly concurrent code easily. This makes Go an excellent choice for applications that require efficient handling of thousands of simultaneous tasks.

Conclusion

To conclude, when it comes to picking a language for application development, Go is a viable option for enterprises. However, it is not likely that Go will completely replace Java, simply because there is no strong reason and enough benefits for companies to migrate entirely from Java to Go. Java is mostly used for developing Android mobile applications, data processing and transforming, and building applications with complex requirements which are heavily reliant on Java’s vast ecosystem of libraries and frameworks. Go is more suitable for building small to medium services, serverless applications, and gives a higher performance when doing concurrent programming. Both languages excel in different areas, and can be used in tandem to build high-performance and reliable applications.

Citations

• Team Veltris. “Golang: A Key Programming Language in Future Enterprise Application Development”, Veltris Blog, December 9, 2019. Link
• Nikhilbhide. “Golang: A Programming Language for Modern Enterprise Applications”, Medium, May 25, 2021. Link
• Victor Björklund. “Will golang replace Java?”, JawDropping.io, March 1, 2022. Link
• Rob Pike. “Go at Google: Language Design in the Service of Software Engineering”, Google Inc, October 25, 2012. Link
• Technoidentity. “Opinion: Go vs Java Microservices”, Technoidentity. Link
• Russell Cohen. “Why you can have millions of Goroutines but only thousands of Java Threads”, RCoh’s Blog, April 12, 2018. Link