Why Go Skips Some Features: A Look into Go's Design Choices and Simplicity

Go, also known as Golang, is celebrated for its simplicity, efficiency, and ease of use. However, it omits several features found in other languages like Java, Python, and C++. Understanding why Go makes these omissions can provide valuable insights into its design philosophy and the benefits it offers. Here’s a brief exploration of the features Go does not support and the rationale behind these design choices.

1. Inheritance and Multiple Inheritance

In Java:

class Animal {
    void speak() { System.out.println("Animal speaks"); }
}

class Dog extends Animal {
    @Override void speak() { System.out.println("Dog barks"); }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.speak(); // Output: Dog barks
    }
}        

In Go:

package main

import "fmt"

type Animal struct{}
func (a Animal) Speak() { fmt.Println("Animal speaks") }

type Dog struct { Animal }
func (d Dog) Speak() { fmt.Println("Dog barks") }

func main() {
    dog := Dog{}
    dog.Speak() // Output: Dog barks
}        

• Reason for Omission: Go uses composition instead of inheritance to avoid complex hierarchies and encourage modular code. The Dog type embeds Animal and has its own Speak method, promoting flexibility and simplicity.

2. Pointer Arithmetic

In C:

#include <stdio.h>

int main() {
    int arr[3] = {1, 2, 3};
    int *ptr = arr;
    printf("%d\n", *(ptr + 1)); // Output: 2
    return 0;
}
        

In Go:

package main

import "fmt"

func main() {
    arr := []int{1, 2, 3}
    // Go does not support pointer arithmetic directly
    fmt.Println(arr[1]) // Output: 2
}
        

• Reason for Omission: Go avoids pointer arithmetic to enhance safety and prevent errors. It uses safe indexing operations to manage memory access.

3. Method Overloading

In Java:

class Printer {
    void print(int number) { System.out.println("Printing number: " + number); }
    void print(String text) { System.out.println("Printing text: " + text); }
}

public class Main {
    public static void main(String[] args) {
        Printer printer = new Printer();
        printer.print(123);  // Output: Printing number: 123
        printer.print("Hello"); // Output: Printing text: Hello
    }
}
        

In Go:

package main

import "fmt"

func PrintNumber(number int) { fmt.Println("Printing number:", number) }
func PrintText(text string) { fmt.Println("Printing text:", text) }

func main() {
    PrintNumber(123)    // Output: Printing number: 123
    PrintText("Hello") // Output: Printing text: Hello
}
        

• Reason for Omission: Go requires unique method names to keep code straightforward. Instead of method overloading, Go uses distinct function names for different types.

4. Method Overriding

In Java:

class Parent {
    void greet() { System.out.println("Hello from Parent"); }
}

class Child extends Parent {
    @Override void greet() { System.out.println("Hello from Child"); }
}

public class Main {
    public static void main(String[] args) {
        Parent p = new Child();
        p.greet(); // Output: Hello from Child
    }
}
        

In Go:

package main

import "fmt"

type Parent struct{}
func (p Parent) Greet() { fmt.Println("Hello from Parent") }

type Child struct { Parent }
func (c Child) Greet() { fmt.Println("Hello from Child") }

func main() {
    var p Parent = Child{}
    p.Greet() // Output: Hello from Child
}
        

• Reason for Omission: Go uses embedded structs and explicit method definitions to achieve similar results. This approach maintains simplicity and clarity without traditional class hierarchies.

5. Class-Based Object-Oriented Programming:

• Reason for Omission: Go opts for a more procedural style with structs and methods, which aligns with its design goals of simplicity and avoiding the overhead of traditional OOP paradigms.

6. Exceptions (Error Handling):

• Reason for Omission: Go uses a simple error handling approach where functions return error values, and errors are handled explicitly. This design choice emphasizes explicit handling of errors, making code more predictable and forcing developers to consider error cases explicitly.

7. Operator Overloading:

• What It Is: Operator overloading allows operators (e.g., +, -, *) to be redefined for user-defined types.
• Reason for Omission: Go avoids operator overloading to keep the language simpler and prevent the potential confusion and misuse of operators. It encourages using functions or methods with descriptive names for custom operations.

8. Generics (Before 1.18):

Generics were not initially included to keep the language simple. However, Go 1.18 introduced generics to enhance code reusability and type safety while maintaining Go's core principles.

Conclusion

Go’s design emphasizes simplicity, safety, and efficiency. By omitting features like Classic OOPs, inheritance, multiple inheritance, method overloading, Method overriding, Operator overloading, pointer arithmetic, General Try Catch Exception handling. Go avoids complexity and potential pitfalls. Instead, Go promotes clear, maintainable code through composition, explicit interfaces, and other straightforward mechanisms. Understanding these choices can help developers appreciate Go’s design philosophy and leverage its strengths effectively.

Q: So does this mean these features are not so important for developing an application in other languages like Java but is just present to provide a kind of flexibility or ease of use for developer/language?

Please share your opinions on this.