Our Golang Frameworks vs Ruby Frameworks Expert Guide for Software Developers

As the Ruby on Rails community becomes increasingly mature, additional time is spent optimizing different aspects of the Ruby framework rather than creating a completely new web application. This means performance and memory consumption start to play a significant role in its day-to-day development. So now we have much more instantaneous communication, lots of API calls and open connections needs to be processed. This evolution is apparent from the way Rails 5 was developed. ActionCable and API mode for Rails are selling features of Rails 5 due to the program’s advances over time.

As in-depth and technical as Ruby On Rails can be, it is still an exceptional tool for back-end development. Check out our

case study

where we used Ruby On Rails and built a mobile app within 3 months that shared 90%+ of code between iOS and Android, as well as important structural commonalities between mobile and web versions.

But what happens if you still encounter problems with performance and concurrency? Luckily,

the

Golang

framework

has the capacity to address some of these issues in certain circumstances.

To be clear, however, this article isn’t designed as a complete guide to explain Golang’s most complex facets. Instead, it presents similarities between

Ruby web frameworks

and

Golang web frameworks

-

the two major frameworks of Golang and Ruby. Therefore, the purpose is to compare Ruby on Rails versus Beego. In the process, the objective is to discover familiar ways to perform functions in

Goland frameworks

if you already have some experience using

Ruby

frameworks

.

Getting Up and Running

The first step is to install Beego and Rails.

Installation

Fortunately, the installation itself is fairly simple. In fact, the only difference is that for a more robust experience, you have to install the Bee command. That’s the Rails alias for Beego, which allows you to run several useful commands in order to get up and running as fast as possible. Here are your typical workflows in Rails and the equivalent in Go

Installing Ruby Frameworks

1$ gem install rails

Now let’s install the required packages for Beego:

Installing Golang Frameworks

1$ go get github.com/astaxie/beego
2  $ go get github.com/beego/bee

Make sure that after the installation, Bee will be somewhere in the

$PATH.

To be confident everything is correct, run “bee -h” and if “bee” was installed properly, you will see the following help information:

1$ bee -h
2Bee is a fast and flexible tool for managing your Beego web application.
3  USAGE
4    bee command [arguments]
5
6  AVAILABLE COMMANDS
7
8    version     Prints the current Bee version

Now we can start our journey into the Beego app development. To begin, it’s best to try to find equivalents for everyday tools that are already used in Rails.

Generators

When Rails became a popular program, one of the most innovative aspects was its generators. This tool impressed newcomers with its simplicity and speed. Today, it might be difficult to imagine any kind of mature framework that does not include a code generator tool in a toolchain. Below, you will see the most common cases solved for both Ruby and Go.

Ruby Framework Generators

1$ rails new ror

Golang Framework Generators

1$ bee new beeapp

You can generate controllers, models, migrations, even scaffolds. So from this point of view, you have all of the familiar tools out of the box.

Start the Engine

Both frameworks (Rails and Beego) come with numerous helpful tools that are designed to assist you. Now let's try them out.

Starting Up Ruby Frameworks

1$ rails s
2
3  => Booting Puma
4  => Rails 5.1.2 application starting in development on https://localhost:3000
5  => Run `rails server -h` for more startup options
6  Puma starting in single mode...
7  * Version 3.9.1 (ruby 2.3.4-p301), codename: Private Caller
8  * Min threads: 5, max threads: 5
9  * Environment: development
10  * Listening on tcp://0.0.0.0:3000
11  Use Ctrl-C to stop

Starting Up Golang Frameworks

1$ bee run
2
3  ______
4  | ___ \
5  | |_/ /  ___   ___
6  | ___ \ / _ \ / _ \
7  | |_/ /|  __/|  __/
8  \____/  \___| \___| v1.8.4
9  2017/07/15 22:58:35 INFO     ▶ 0001 Using 'beeapp' as 'appname'
10  2017/07/15 22:58:35 INFO     ▶ 0002 Initializing watcher...
11  beeapp/controllers
12  beeapp/routers
13  beeapp
14  2017/07/15 22:58:37 SUCCESS  ▶ 0003 Built Successfully!
15  2017/07/15 22:58:37 INFO     ▶ 0004 Restarting 'beeapp'...
16  2017/07/15 22:58:37 SUCCESS  ▶ 0005 './beeapp' is running...
17  2017/07/15 22:58:37 [I] [asm_amd64.s:2197] https server Running on https://:8080

Dependency Management

As your application grows, you will start to use more and more third party packages. So it’s crucial to have a reliable dependency management tool in place. Let’s take a look at how we can use this approach.

1$ bundle install
2  $ glide init

With the above method in place, we can now examine a particular part of our app. First of all, we need to generate a basic model and see the difference between the ActiveRecord model and the Gorm.

Models

At the heart of any app, you’ll find data layers. So from this point, it’s best to start our feature comparison from Models. But first, let's talk a bit about the Model from the MVC pattern. This is a foundation of your project and the most important part of the app. By default, Beego is fully packed with ORM (Object Relational Mapping) and migrations support. Still, we should take advantage of the nature of Go projects and replace the default ORM with

Gorm

.

Ruby Framework Models

1$ rails g model post titel:string body:text
2      invoke  active_record
3      create    db/migrate/20170717150150_create_posts.rb
4      create    app/models/post.rb
5      invoke    test_unit
6      create      test/models/post_test.rb
7      create      test/fixtures/posts.yml

Golang Framework Models

1$ bee generate model post -fields="title:string,body:text"
2  ______
3  | ___ \
4  | |_/ /  ___   ___
5  | ___ \ / _ \ / _ \
6  | |_/ /|  __/|  __/
7  \____/  \___| \___| v1.8.4
8  2017/07/17 18:07:22 INFO     ▶ 0001 Using 'Post' as model name
9  2017/07/17 18:07:22 INFO     ▶ 0002 Using 'models' as package name
10    create   ~/.go/src/beeapp/models/post.go
11  2017/07/17 18:07:22 SUCCESS  ▶ 0003 Model successfully generated!

By default, you can generate models right from the CLI (Command Line Interface) with the Bee app. But it must use default ORM. So if we want to experience advantages from the

Gorm

, we need to perform this setup manually.

1models
2  ├── connection.go
3  └── post.go
4  models/connection.go
5  package models
6
7  import (
8    "github.com/jinzhu/gorm"
9    _ "github.com/jinzhu/gorm/dialects/sqlite"
10  )
11
12  var DB *gorm.DB
13
14  func GetNewConnection() *gorm.DB {
15    if DB != nil {
16      return DB
17    }
18
19    db, err := gorm.Open("sqlite3", "test.db")
20    if err != nil {
21      panic("failed to connect database")
22    }
23    // defer db.Close()
24
25    DB = db
26    return DB
27  }
28  models/post.go
29  package models
30
31  import (
32    "github.com/jinzhu/gorm"
33  )
34
35  type Post struct {
36    gorm.Model
37    Title string
38    Body  string
39  }
40  main.go
41  package main
42
43  import (
44    "beeapp/models"
45    _ "beeapp/routers"
46
47    "github.com/astaxie/beego"
48  )
49
50  func main() {
51    beego.Run()
52    models.GetNewConnection()
53  }

Controller

At this time, we are ready to work with data and able to perform basic

CRUD

operations. So it makes sense to add some controllers and actions. We can generate a controller in the same manner as we do in Rails.

Ruby Framework Controller

1$ rails g controller Posts index
2      create  app/controllers/posts_controller.rb
3       route  get 'posts/index'
4      invoke  erb
5      create    app/views/posts
6      create    app/views/posts/index.html.erb
7      invoke  test_unit
8      create    test/controllers/posts_controller_test.rb
9      invoke  helper
10      create    app/helpers/posts_helper.rb
11      invoke    test_unit
12      invoke  assets
13      invoke    coffee
14      create      app/assets/javascripts/posts.coffee
15      invoke    scss
16      create      app/assets/stylesheets/posts.scss

Golang Framwork Controller

1$ bee generate controller Post
2  ______
3  | ___ \
4  | |_/ /  ___   ___
5  | ___ \ / _ \ / _ \
6  | |_/ /|  __/|  __/
7  \____/  \___| \___| v1.8.4
8  2017/07/17 18:56:55 INFO     ▶ 0001 Using 'Post' as controller name
9  2017/07/17 18:56:55 INFO     ▶ 0002 Using 'controllers' as package name
10  2017/07/17 18:56:55 INFO     ▶ 0003 Using matching model 'Post'
11    create   ~/.go/src/beeapp/controllers/post.go
12  2017/07/17 18:56:55 SUCCESS  ▶ 0004 Controller successfully generated!

As you can already see, there are many parallels between Beego and Rails. Both frameworks aim to be "full featured" and incorporate all of the aspects that you need in your day-to-day development. In addition, the shape of these frameworks are the same and they solve similar problems. Despite that similarity in basic concepts and the scaffolding process, there is a significant difference between these frameworks. They are implemented in completely different languages and there are numerous corner cases. We can now take a look and apply logic into this process. One of the most eye catching differences is that we work with data in using Go. On the surface, Rails might look different. However, it operates in a similar way. Therefore, you can set up Rails to look something like this:

1def index
2    @users = User.all
3  end
4
5  def show
6    @user = User.find(params[:id])
7  End

Compared to Beego, you should perform the following steps:

1// GetAll ...
2  // @Title Get All
3  // @Description get all Posts
4  // @Success 200 {object} models.Post
5  // @Failure 403
6  // @router / [get]
7  func (c *PostController) GetAll() {
8    posts := []models.Post{}
9
10    if err := models.GetNewConnection().Find(&posts).Error; err != nil {
11      c.Data["json"] = err.Error()
12    } else {
13      c.Data["json"] = posts
14    }
15    c.ServeJSON()
16  }
17
18  // GetOne ...
19  // @Title Get One
20  // @Description get Post by id
21  // @Param id    path  string  true    "The key for staticblock"
22  // @Success 200 {object} models.Post
23  // @Failure 403 :id is empty
24  // @router /:id [get]
25  func (c *PostController) GetOne() {
26    idStr := c.Ctx.Input.Param(":id")
27    id, _ := strconv.ParseInt(idStr, 0, 64)
28    post := models.Post{}
29
30    if err := models.GetNewConnection().First(&post, id).Error; err != nil {
31      c.Data["json"] = err.Error()
32    } else {
33      c.Data["json"] = post
34    }
35    c.ServeJSON()
36  }

From this example, you can already observe that in Go you have to be much more explicit about your commands. In short, you must handle “Record Not Found” by yourself and take care of this issue right within the action. This means you need to cast your params manually without later relying on type casting.

Go vs Ruby Conclusion and Cheat Sheet

Rails was the first of its kind and paved the way for other sophisticated frameworks. In fact,

the

Goland framework

is widely considered to

have

many

Ruby framework

characteristics. It provides a full range of tools to work with in your Model, View and Controller layers, which are similar to Rails. Beego has also created extensive routing in streamlined form as well as many other crucial features. It’s worth noting that both Beego and Rails are great tools with minimal overhead required for the mental model switch.

If you hit the performance wall and don’t want to reinvent the wheel, you may consider replacing some parts of your Rails app with Beego to save significant time and effort. Having such advanced products in your toolchain can be very helpful for a wide assortment of projects. Overall, if you have a Rails background and you want to leverage certain advantages from

a

Golang

framework

, try Beego. It might be a great start for your Golang journey.

Goland frameworks

have proven to be useful and efficient time and time again. We even used it in one of our

case studies

to help a business expand their offerings in the on-demand mobility space, connect customers with transportation, goods and services, and improve their marketplace.

In addition, here is a helpful cheat sheet that you can use for comparison as you progress forward.

Rails | Beego

rails new [appname] | bee new [appname]

rails s | bee run

bundle install | glide install

rails g model post titel:string body:text | bee generate model post -fields="title:string,body:text"

rails g controller Posts | bee generate controller Post

Links

• https://guides.rubyonrails.org/
• https://beego.me/