Author at Infinum

Building Web Apps with GO

Ivan Lučin — Tue, 04 Oct 2016 18:00:00 +0000

GO is a newcomer to the world of programming. An open source, statically typed programming language developed by Google that provides you with some nice features like garbage collection, memory safety and facilities for writing concurrent programs.

If you’re a developer, you’ve probably heard about it and you’re interested in a more personal opinion. Well, it’s a “C(++) like” language with an improved, simplified syntax and a few unusual features that make it stand out. It is a pretty controversial language in my opinion, taken some of its core design decisions. For example:

You expose a public method from the module by naming it so that the first letter is uppercase
It enforces a specific directory structure of packages by using domain names as directory names
It doesn’t allow you to expose an undocumented public API

Upon first encounter, developers are usually horrified by this, but the philosophy behind the language is clear. To provide simple but powerful constructs with well-defined conventions, making developers more productive (and happier).

Okay, let’s make a quick overview of the GO ecosystem and dive a bit deeper.

About the language

The first thing everybody notices while learning a new language is its syntax. GO has a pretty simple and concise syntax, making it a great language to start with. You’re probably familiar with the overwhelming feeling when you’re just figuring out a new programming language. After I did “A Tour of GO” I wasn’t terrified. On the contrary, I felt like everything just made sense. Authors of the language gave their best to keep things simple.

Gopher, GO’s lovable mascot

In the world of GO, everything is made out of packages which are usually designed following the main UNIX philosophy – “Do one thing and do it well”. This leads to reusable and understandable code which is a great thing, especially if you’re still learning how to program.

GO’s type system is also pretty straightforward. It revolves around structs (data objects) and methods (behavior) usually attached to those data structs. A data struct with a set of methods can satisfy an interface which is used elsewhere to achieve decoupling. This is similar to the concept of “class” most developers are familiar with, but it is done quite differently. One thing I really like about GO’s type system is that it enforces good object-oriented practices like “Composition over inheritance”. On the other hand, people starting with GO often complain that it’s missing object-oriented features and feel constrained with its approach. You’ve probably heard similar remarks made about JavaScript’s prototype inheritance.

One cool GO feature I really like is function closure. You can use it just like you would in JavaScript. Check out this Fibonacci calculator using a function closure to encapsulate the last iteration state:

package main

import "fmt"

// fibonacci returns a function that returns fibonacci numbers 
// from each successive call
func fibonacci() func() int {
    first, second := 0, 1
    return func() int {
        ret := first
        first, second = second, first+second
        return ret
    }
}

func main() {
    f := fibonacci()
    for i := 0; i < 10; i++ {
        fmt.Println(f())
    }
}

Since GO is a statically typed language, you can expect a minimal amount of runtime errors. At Infinum, we’re mostly working with dynamic languages so runtime errors are the only errors we’re dealing with. Because of that, writing GO programs felt like a pretty relaxed job, once you get a piece of code to compile, it just works.

GO is all about concurrency, but writing concurrent programs is hard. To create a concurrent program one would usually run a thread that communicates with other threads through shared data or message passing mechanisms. GO tries to simplify this process by introducing two new concepts right into the language:

GO routines – a lightweight thread of execution
Channels – a connection facility between GO routines

Go ahead and try them out. It’s really simple.

GO comes with a nice set of development tools like a blazing fast compiler, code formatter, debugger, package manager etc. For example, there’s GOfmt which formats your code according to standard rules. This is not optional → you have to obey GO’s conventions. You can easily integrate GO tools with any popular text editor/IDE like Atom, Sublime, Vim or others.

Web development with GO

GO is well suited for web development. Its standard library is backed by a great net/http package providing you with everything you need to implement a simple, concurrent web server in just a few lines of code.

Here’s a simple web server example:

package main

import (
    "io"
    "net/http"
)

func hello(w http.ResponseWriter, r *http.Request) {
    io.WriteString(w, "Hello world!")
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", hello)
    http.ListenAndServe(":8000", mux)
}

But you probably need something more than just a standard library for your web projects, you’re probably looking for a framework.

A few popular ones are:

gorrilla/mux, martini, negroni, gin – routing with extendable middleware
revel, iris – full frameworks with routing, view rendering, sessions, REST APIs, websockets etc.

While some give you just basic routing support, others are trying to solve all standard problems in backend web development. In the GO ecosystem, you won’t find massive MVC frameworks (like Ruby on Rails) that solve just about everything, since that doesn’t fit well with the core philosophy of the language. You’ll find simpler and more focused packages because Gophers believe that’s the way software should be built.

While developing backend apps, you usually need a data persistence layer of some sort. A quick Google search will give you something like:

gorm – full ORM library
gorp – simpler persistence layer
sqlx – a low-level extension to GO’s standard database/sql package

And what about view rendering? Well, there’s a cool html/template package giving you basic building blocks for connecting HTML templates with your program, or encoding/json if you’re building an API and need to render some JSONs. If you want a complete view renderer that abstracts a few things, you can check out the render package that plays nicely with many middleware libraries mentioned above.

So, if you want to do web development in GO you can find a package for almost everything. Here’s a long list of libraries that might prove useful. Be cautious, this is a pretty young ecosystem and you could encounter a lack of documentation or support while using some of those packages.

Personal experience

At Infinum, we constantly explore new technologies. A great way to do that is to organize an internal hackathon where everybody has to build something with a completely new language, framework or library. We did that about a year ago and my friend Krešo and I decided to give GO a shot.

The idea was to create a web app that’s simple, useful and covers standard problems in web development (routing, database, connecting to other APIs). The result was an app called “Managing dependency management”. It scans public GitHub repositories, analyses root package.json files and prints out which dependencies (npm packages) are out of date. We used martini web framework, postgres database, gorm data layer, GitHub’s library and managed to make everything work in just under 8 hours.

GO in action

After our test run proved to be successful, we decided to incorporate GO in our client work. We’re working with Startup Threads, a US company that prints and sends custom T-shirts worldwide.

Need a T-shirt with a gopher?

We’ve built a fast web server in GO that does image analysis on user-uploaded print art. It’s a scalable, Heroku-based architecture which was fairly easy to setup. In the end, GO made automatic deployment really fast and reliable.

Wait! But why GO?

You’re probably asking yourself this question. Why should I use GO when there are other, more established and mature ecosystems for web development? GO’s main selling point is its right combination of productivity, performance and built-in concurrency support. So, if you’re building a simple CMS-like website, GO is not the best tool for the job, but if you need in order to build a high-performance server that handles thousands of requests per second, then GO might be the right fit.

Playing with GO was a great experience and I’ll definitely try building more complex systems with it. The most important benefit is the productivity and easy collaboration achieved through its simplicity and well-defined conventions. Of course, it is not meant to be used for everything, so before you decide to use GO for your next project, research whether it is the right tool for the job.

Have a cool GO project you need help on? Contact us.

Want to know more?

Check out these useful links:

The post Building Web Apps with GO appeared first on Infinum.

The Updatable WebView on Android 5.0 Lollipop What Is It and Why Should You Care?

Ivan Lučin — Tue, 21 Oct 2014 08:12:00 +0000

Last week, Google released Android 5.0, code named Lollipop. It’s the largest and most ambitious release of their mobile OS. One of the new features is called Updatable WebView and it’s particularly interesting to us because we develop lots of hybrid apps.

Hybrid apps are regular native apps that you can install from the App Store or Google Play. They’re developed using web technologies and are run in a component called WebView. WebView is a HTML and Javascript engine that’s used to display websites. It’s like having a browser run in your mobile application, but there’s also a way to access stuff you can’t access from a regular mobile website like the phone’s camera, accelerometer, file system, etc.

The chronicles of a hybrid app developer

The reason why we develop apps that way is that we get to write our code only once, and run it on various mobile and desktop platforms. However, native apps usually perform better and can be tested more easily. So we need to balance between these pros and cons when choosing a development strategy for a new project.

One of the problems with the hybrid approach is that, until now, the WebView component couldn’t compete with a modern mobile browser in terms of features and performance. WebView is offered as an internal component of the mobile OS itself, meaning that updates are only possible when the device’s actual OS is updated.

The main problem is the fragmentation of the Android mobile OS. There are many different vendors creating their own versions of Android and often changing the way internal components work. This makes the hybrid development process more difficult because we have to carefully design and test our apps to run in various environments.

Moving the (hybrid) web forward

Since the release of Android 4.4 KitKat, WebView has been based on Chromium, which means that it has the same rendering and Javascript engine as Chrome for Android. Although it doesn’t have the same features, this is a big thing because the consistency and performance in running web apps have been improved. Besides that, our apps are hardware accelerated by default and we also have an insanely awesome remote debugging feature.

WebView is now updatable… What’s so special about it?

With the new Android 5 Lollipop, Google has pushed hybrid development even further. The Chromium layer behind the WebView component is now updatable from Google Play. This means that every mobile device with Android 5 or later should have not only the same but the latest browsing engine in the WebView. There are several reasons why this is good news:

Users get better and more feature-rich experience in using their web apps,
Hybrid apps are now more consistent between devices and have better performance,
Users don’t have to update their OS to get the latest and best possible browser engine,

… which gets us to the main point of this article:

Developing hybrid apps for Android devices is now much easier and more satisfactory.

Other cool new features

Besides the update part, there are several more notable features (web APIs support) in the new Android WebView:

WebRTC – Real-Time Communications capabilities via Javascript APIs
WebAudio – a powerful and versatile system for controlling audio on the Web
WebGL – Web API similar to OpenGL that provides 3D graphics

The bad parts

Of course, all of this is not of much use at the moment because Android OS usage statistics look like this:

And we still need to support older versions of Android in our hybrid apps, sometimes all the way to Gingerbread. The situation will probably change soon and this is really not that much of an issue in the long run.

But there’s still the problem with Android fragmentation and many different device manufacturers “improving” their own versions of Android. They can (and probably will) change the WebView and adjust it to their own needs. So I guess we’ll keep on fighting WebView device inconsistencies, but at least to a lesser extent.

Is Apple also embracing hybrid development?

Apple has also included some interesting WebView updates in their new iOS 8 release. They’ve created another component (called WKWebView) whose performance will be equivalent to the performance of Safari, the native browser on iOS. To put this into perspective – WKWebView could be up to three times faster than a regular WebView iOS component (called UIWebView).

But don’t get too excited, WKWebView is still not ready for running modern web apps.

To summarize, although many of these features are not ready to be used in real-world scenarios, we can notice that things are getting much better in the field of hybrid app development.

The post The Updatable WebView on Android 5.0 Lollipop What Is It and Why Should You Care? appeared first on Infinum.