I am passionate about Ruby, but its execution time compared to other languages is extremely high, especially when we want to use more complex algorithms. In general, data structures in interpreted languages become incredibly slow compared to compiled languages. Some algorithms such as ´n-body´ and ´fannkuch-redux´ [can be up to 30 times slower in Ruby than Go](https://benchmarksgame.alioth.debian.org/u64q/compare.php?lang=yarv&lang2=go). This is one of the reasons I was interested in embedding Go code in a Ruby environment.
For those who do not know how shared libraries operate, they work in a similar way as DLLs in Windows. However, they have a native code with a direct interface to the C compiler.
> **Note**
> Windows uses the DLL system, and in this case, this does not necessarily have to be in native code.
>
> One example is DLLs written in C#, which runs on a virtual machine. Because I do not use windows, I ended up not testing if it is possible to perform these steps on it.
>
> You need Golang 1.5 or higher and Ruby 1.8.7 or higher.
# 1. Create your Go library!
It would be like any library, but it must have some peculiar characteristics.
## Use C language types
For signing external functions to your library, you will need to use the C language typing. For the rest of the code, you can convert to the standard Go typing.
To do this include library:
```golang
import "C"
```
Remember that this is the Achilles' heel of Go Lang.
Try to generate a small interface, where only few data is carried on. In general, data type translation is extremely slow when converting from Go to C types!
## Function export signature
You need to tell the Go compiler which functions will be public in the library by adding a comment above your function:
```golang
import "C"
//export my_add
func my_add(a, b C.int) C.int {
return a + b
}
func main() {
// This is necessary for the compiler.
// You can add something that will be executed when engaging your library to the interpreter.
}
```
Remember that the exported functions must be in your main package.
> **Note**
> I know that the standard of nomenclatures in Go is different from what we found in this example, but I've created the habit of writing interfaces using the Ruby style. For this reason, the names of the functions are written using `snake_case` and not `camelCase`.
## Compile
Just type:
```sh
go build -o my_lib.so -buildmode=c-shared my_file.go
```
# Writing the interface with the shared library in Ruby
This is the fastest way to embed Go code into a Ruby environment, however, remember that in this way the call time of the go interface will not be so fast.
## Preparing the environment
Add to your `Gemfile` the following gem:
```ruby
gem 'ffi'
```
Or of course, manually install it: `gem install ffi`
## Create a module for your library
Just create a module and write your function signatures inside the Ruby package. This is like a `.h` file:
```ruby
require 'ffi'
module Foo
extend FFI::Library
ffi_lib './my_lib.so'
attach_function :my_add, [:int, :int], :int
end
puts Foo.my_add(2, 2)
# => 4
```
# What I noticed by running native Go code in the Ruby environment?
Integrating Go and Ruby is fast and efficient for certain situations. Running the native code in Go brings several advantages, bringing you various graphical, database and efficient data structures libraries already implemented in Go and the efficiency of Go routines.
Remember that this applies when we use little data translations between Ruby and Go. This will only be advantageous if you have a huge real gain like the algorithms I quoted above, ´n-body´ and ´fannkuch-redux´, offsetting this loss by calling a function through the Go C Library.