Go (often also Golang) is a compiled multi-threaded programming language developed by Google.


    The Go language was developed as a programming language for creating high-performance programs running on modern distributed systems and multi-core processors.

    Programs written in Go are expected to be translated by the compiler into the object code of the target hardware platform and subsequently executed directly, without requiring a virtual machine. The architecture of the language was originally designed to allow fast compilation into efficient object code. Although an interpreter is available for Go, there is almost no great need for an interpreter, since the compilation speed is fast enough to allow interactive development.

    The main features of the Go language:*

    • Go is a language with strict static typing. Automatic type inference is available, for user types - "duck typing".
    • Fully support for pointers, but without the ability to apply arithmetic operations to them, in contrast to C/C++/D.
    • String type with built-in Unicode support.
    • Use of dynamic arrays, hash tables, slices, collection traversal loop option.
    • Functional programming tools: Unnamed functions, closures, function passes in parameters, and function value returns.
    • Automatic memory management with garbage collector.
    • Object-oriented programming tools, but without support for implementation inheritance (only interfaces are inherited). By and large, Go is a procedural language with support for interfaces.
    • The means of parallel programming: threads integrated into the language (go routines), interaction of threads via channels and other means of organizing multithreaded programs.
    • Sufficiently concise and simple syntax, based on C, but significantly refined, with a lot of syntactic sugar.

    At the same time, the language deliberately did not include a number of popular tools.

    • The structural notation of exception handlers is considered to provoke error skipping or inadequate error handling. Instead, it is proposed to check return codes using multi-digit functions and special error interface, as well as to use deferred functions to catch exceptional situations.
    • Implementation inheritance, the authors argue, leads to hard-to-maintain code with implicit dependencies. Similar features, but without undesirable inheritance effects, are provided by type nesting support and freely defined interfaces.
    • Generalized programming. The authors are not fundamentally against generic programming and do not exclude adding this feature to the language, but so far they refrained from it, because, according to them[3], the possibilities provided by this innovation does not compensate the required complication of the compiler and runtime-libraries. Besides, the means already available in the language (empty interfaces, "uti typing" and reflexion) allow to create generalized code without special syntactic mechanisms.
    • The use of assertions was considered unnecessary.
    • The redefinition of methods and functions has been eliminated for compilation efficiency reasons: the requirement of different naming eliminates the need to compare parameter lists when compiling function and method calls, while this possibility itself is nothing more than syntactic sugar.

    go 1.9 - aliases of type names added to the language, some aspects of the use of floating-point operations clarified, toolkit optimized, libraries added, in particular - thread-safe type map.