Go migration guide: Node.js, Python, and Rust

The Go programming language is famous for its expressivity, simple syntax, and other features. Go is mainly targeted for building scalable, reliable software systems due to its performance, concurrency support, simplicity, and efficient memory management via a non-generational concurrent, tricolor mark-and-sweep garbage collector.

Over the years, Go has amassed adoptions in many fields, especially for server-side development. Many companies and developers have turned to Go for their applications over other languages for scalability and other reasons. Go also provides cross-compilation across some supported languages like C and C++, and there are many tools for cross-compiling other languages to Go and vice-versa.

Migrating to a new programming language may be complex, and it’s a process that requires careful planning and consideration; however, a successful migration might prove to be beneficial for your apps.

This article provides an overview of the migration process from Node.js, Python, or Rust to Go. We will also discuss best practices and tips for a successful migration.

Jump ahead:

• The migration process
  • Migrating your existing codebases to Go
• Migrating from Python to Go
  • Manual migration
  • Automatic migration
• Migrating from Rust to Go
• Migrating from Node.js to Go

The migration process

Before migrating between languages, one of the first things you’ll want to consider is the tradeoffs between the features of the languages and the features you want to harness.

There’s more to migrating codebases than rewriting or translating the codebase for equivalent functionality. The various programming languages have different features and trade off on multiple features.

For example, most garbage-collected languages trade off on express access to memory management which may be important for building low-level software like operating systems and browsers. Here are a few actionable steps to migrate your existing codebases to Go.

Migrating your existing codebases to Go

First, you’ll need to analyze your current codebase to identify the potential issues that may arise from migrating. For example, third-party library support, functionality support, and more. The next step is to plan your migration process.

This step would require you to section or create a timeline for the migration process so that your codebase is migrated correctly without breaking existing code and requirements for the migration are available.

Once all requirements are met, you can convert or cross-compile your existing code to your language of choice — in this case, Go. There are tools in the Go ecosystem for automatic and manual code conversion, such as gopherjs or gopy.

After converting/cross-compiling to your target language, you’ll need to test the code to ensure that all the functionalities work as planned and the essence of the migration is achieved. You can perform unit tests, integration tests, and performance and stress tests to ensure your applications are stable, scalable, and reliable.

The final stage of a typical migration process is deployment. If the code works as planned and the migration is successful, you can deploy to new or existing infrastructure that supports the new language.

A successful migration process is one where the end goal of the migration is achieved, the code works as planned, and the new features are harnessed. Migration may be expensive, especially for large codebases. Thus, you must consider the steps above for a successful migration process.

Migrating from Python to Go

Python is a high-level, garbage-collected, interpreted programming language with applications in web development, data analysis, scientific computing, and artificial intelligence. Like Go, Python is primed for its simplicity and readability, and the language has a thriving ecosystem of third-party libraries and frameworks.

Migrating your Python code to Go means that you’re migrating a web-based application. This is because, at the time of this writing, Go isn’t famous for any other applications, such as Python. It may be risky to migrate AI and data analysis codebases from Python to Go.

Migrating your Python codebase to Go is a great way to increase the scalability of your application. You get to harness Go’s concurrency features and data types. Once you’ve familiarized yourself with the syntax of both languages, you can migrate your code manually or automatically.

Manual migration

For manual migration, you’ll need to consider the difference in data types and syntax while taking note of the features you want to harness and the difference in the programming languages.

Here’s an example of a Python function that takes a list of numbers as an argument and returns the sum of the numbers:

# python
def sum_numbers(numbers):
    total = 0
    for number in numbers:
        total += number
    return total

Here’s the Go equivalent of the code:

// golang
func sumNumbers(numbers []int) int {
    total := 0
    for _, number := range numbers {
        total += number
    }
    return total
}

Go doesn’t use lists. The data type is called a slice. Also, indentation doesn’t matter as much in Go as it does in Python. Also, Python doesn’t require a return type for functions as Go mandates. These are one of the many factors you’ll want to consider for manual migration.

Automatic migration

For automatic migration, you can use a code conversion library that does all the code rewrites while you manually test that the code works as intended. Here are a few libraries you can check out for converting Python code to Go.

The gopy package is a Go library for writing Python extensions in Go. The package provides functionality for calling Go functions from Python, vice-versa, and many other functionalities.

Run this command in the terminal of your working directory to install the gopy package:

# shell
go get github.com/go-python/gopy

Here’s an example of how you can use the gopy package to convert Python code to Go code by loading the Python file to the package:

// golang
package main

import (
        "fmt"

        "github.com/go-python/gopy"
)

func main() {
        // Initialize the Python interpreter
        initErr := gopy.Initialize()
        if initErr != nil {
                fmt.Println(initErr)
                return
        }
        defer gopy.Finalize()

        // Convert the Python code to Go code
        convertedCode, convertErr := gopy.Convert("python_code.py")
        if convertErr != nil {
                fmt.Println(convertErr)
                return
        }

        fmt.Println(convertedCode)
}

In the code example, the Convert function takes the path to the Python file as an argument and returns the equivalent Go code as a string.

The py2go package provides a command line utility for converting Python code to Go with a broader range of Python constructs from classes to functions and modules and generates idiomatic Go code.

The pigo package contains tools for converting Python code to C, which can then be compiled and linked with the Go runtime during compilation to produce a Go executable. It can handle a variety of Python features, such as classes, functions, and modules, and it produces effective clear-cut C code.

Keep in mind that you must test the status of the code conversion before deploying your code for whatever use case.

Migrating from Rust to Go

According to the official website, Rust is a popular systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety. Rust was developed by the Mozilla Foundation in 2010 and has gained a reputation among developers for its performance, reliability, and safety features.

Rust and Go are both modern programming languages for building scalable systems. Rust and Go are used to build scalable web applications that serve many users.

By design, Rust and Go are very different, both syntactically and otherwise. Go manages memory using a garbage collector, unlike Rust which uses a borrow checker to enforce its ownership rules for flexibility and efficient memory management.

Another difference between the languages is that Rust is statically typed, and Go is dynamically typed. Finally, the languages have different approaches to concurrency. Rust uses a system of thread-safe references and mutexes to ensure safe data accessibility, while Go uses channels and goroutines for multi-thread communication.

The process of migrating Rust code to Go code and vice-versa is the same. You’ll need to follow the migration processes discussed above.

Here’s a typical Rust function where you must specify the return type of a function.

// rust
fn add(x: i32, y: i32) -> i32 {
    x + y
}

The add function adds two 32-bit integers and returns the equivalent 32-bit integer.

Here’s the Go equivalent of the add function where the return type is inferred from the return statement:

// golang
func add(x int, y int) int {
    return x + y
}

You’ll need to master both languages for both manual and automatic conversion since there are a lot of differences between the languages. Go is easier to learn and work with than Rust, which has a steep learning curve. You can brush up on Rust with this beginner’s guide.

Unfortunately, there are no code conversion tools for automatic migration between Rust and Go at the time of this writing. However, there are packages like the golang-rs package that helps with converting Go structs to Rust structs if you’re looking to migrate your Go codebase to Rust.

Migrating from Node.js to Go

JavaScript is a versatile programming language mainly used to create interactive, dynamic websites and web applications. JavaScript can run on browsers, mobile, and many engines, making JavaScript suitable for building frontend and backend applications for many environments.

JavaScript and Go are both used as backend languages, but there are differences between the languages. For example, JavaScript is a dynamically typed language, while Go is statically typed. Go has support for concurrency, and JavaScript doesn’t have native support for concurrent operations.

The processes for manual code migration from JavaScript to Go are the same as those above. You’ll need reasonably good expertise in both languages while you manually Go through each line and rewrite the corresponding code.

Here’s a function that adds two integers in JavaScript:

// javascript
function add(x, y) {
  return x + y;
}

Here’s the corresponding code written in Go:

// golang
func add(x int, y int) int {
  return x + y
}

The Go function requires typing for the arguments and return type. However, JavaScript uses semi-columns and no indentations.

For automatic code migration, you can use the gopherjs package to convert JavaScript code to Go and vice-versa, although the JavaScript to Go functionality isn’t full-fledged.

Run this command in the terminal of your working directory to install the gopherjs package:

# shell
go get github.com/gopherjs/gopherjs

Here’s an example of converting a JavaScript function to Go code:

// golang
import (
        "fmt"
        "github.com/gopherjs/gopherjs/js"
)

func main() {
        // Convert the JavaScript code to Go code using GopherJS
        convertedCode := js.Global.Get("eval").Invoke("(function() { return 'Hello, World!'; })()")

        // Print the result of the converted code
        fmt.Println(convertedCode.String()) // Output: "Hello, World!"
}

The example uses the eval function in JavaScript to execute a JavaScript function that returns the string “Hello, World!” that is printed to the console with the fmt package.

Conclusion

This article has served as a Go migration guide for Rust, Node.js, and the Python programming language. You learned about the migration process and the differences between the languages and Go, and you overviewed automatic code migration using some Go packages.

In my opinion, the most crucial step in a code migration process is testing the code for errors, and you shouldn’t skip this step to avoid breaking existing functionalities.