Go vs ActFramework
When comparing Go vs ActFramework, the Slant community recommends Go for most people. In the question“What are the best web frameworks to create a web REST API?” Go is ranked 2nd while ActFramework is ranked 20th. The most important reason people chose Go is:
The language is designed in a manner that seems logical. Syntax is simplified to reduce burden on the programmer and compiler developers.
Specs
Ranked in these QuestionsQuestion Ranking
Pros
Pro Simplified C-like syntax that is as easy to read and write as Python
The language is designed in a manner that seems logical. Syntax is simplified to reduce burden on the programmer and compiler developers.
Pro Great team working behind it
Go has a solid team of engineers working on it (some of the best networking engineers in the world are working on Go). Up until now, the great engineering of the language has compensated for its lack of power.
Pro Easy to install and configure; simple to compile software
Go software can be immediately installed, regardless of your operating system, package manager, or processor architecture with the go get command. Software is compiled statically by default so there is no need to worry about software dependencies on the client system. Makefiles and headers are no longer necessary, as the package system automatically resolves dependencies, downloads source code and compiles via a single command: go build
.
Pro Programmers don't have to argue over what 10% subet of the language to implement in their software project
The language promotes programming in a specific idiomatic style, which helps keep every programmer on the same page.
Pro Supports 'modules' in the form of packages
Every Go source file contains a package line that indicates which package a file belongs to. If the name of the package is 'main', it indicates that this is a program that will be compiled into a binary. Otherwise, it will recognize that it is a package.
Pro Demonstrates a unique, simple concept to object-oriented programming
All types are essentially objects, be they type aliases or structs. The compiler automatically associates types to their methods at compile time. Those methods are automatically associated to all interfaces that match. This allows you to gain the benefits of multiple inheritance without glue code. As a result of the design, classes are rendered obsolete and the resulting style is easy to comprehend.
Pro Great language for building networking services
Go was started as a systems language but now it has fully committed in the niche of networking services. This has been a brilliant move by Go because it allows them to capitalize on the immense talent of the Go engineering team (who are in the most part network engineers).
In a world dominated by Java EE and slow scripting language, Go was a breath of fresh air and it continues to be one of the most powerful languages if you want to build networking services.
Pro Exceptionally simple and scalable multithreaded and concurrent programming
Goroutines are "lightweight threads" that runs on OS threads. They provide a simple way for concurrent operations — prepending a function with go
will execute it concurrently. It utilizes channels for communication between goroutines which aids to prevent races and makes synchronizing execution effortless across goroutines. The maximum number of OS threads goroutines can run on may be defined at compile time with the GOMAXPROCS
variable.
Pro The go compiler compiles binaries instantly — as fast as a scripting language interpreter
Compiled binaries are fast — about as fast in C in most cases. Compiles on every OS without effort — truly cross-platform compiler. As a result of the fast compilation speed, you can use the gorun program to use go source code as if it was a scripting language.
Pro Performance is on the order of C and Java
Go is blazing fast, but easier to write than Python, JS, Ruby, or many other dynamic languages.
Pro Jobs available
You can find a Job knowing Go. Which is more than can be said with many other languages.
Pro API documentation is rich in content; easy to memorize
Only features deemed critical are added to the language to prevent cruft from working its way into the language. The language is small enough to fit inside one's head without having to repeatedly open documentation. Documentation is hosted on an official webpage in a manner that is simple to read and understand.
Pro Supports functional programming techniques such as function literals
This naturally also supports first class and high order functions, so you may pass functions as variables to other functions.
Pro Multiple variables may be assigned on a single line
This conveniently eliminates the need to create temporary variables.
Fibonacci example: x, y = y, x+y
Pro Built-in unit testing
The idiomatic approach to writing a Go software project is to perform test-driven development with unit testing. Every source code file should have an associated *_test.go
file which tests functions in the code.
Pro Provides tools for automatically formatting code for your entire software project
This helps keep every programmer on the same page in a project and eliminates arguments over formatting styles.
Pro Automatically generates API documentation for installed packages
Godoc is provided to automatically generate API documentation for Go projects. Godoc also hosts its own self-contained web server that will list documentation for all installed packages in your Go path.
Pro Supports splitting source code into multiple files
As long as every source code file in a directory has the same package name, the compiler will automatically concatenate all of the files together during the compilation process.
Pro Syntax for exported code from a package is simplified to be less verbose than other languages
Any variable, type and function whose name begins with a capital letter will be exported by a project, while all other code remains private. There is no longer a need to signify that a piece of code is 'private' or 'public' manually.
Pro Performance
There are two aspects of performance: how quick a developer can deliver a feature and how fast the app is running on the product server. Act is designed to deliver excellent results in both aspects. With unbeatable developing experience, Act makes it very easy to release a feature; on the other side Act is very fast in runtime. Check out this 3rd party benchmark result.
Pro Hot reload
You never restart while you're working on your Act application. Act's hot reload feature is fast and stable, it makes you feel like dealing with scripting language frameworks like Django or NodeJs. Watch this video and feel it.
Pro Scalability
Act is built as a stateless framework. It supports horizontal scale.
Pro Secure
Act is built as a secure product. It provides built-in CSRF/XSS prevention mechanism. And act-aaa makes it very easy to implement Authentication/Authorization/Auditing in your app.
Pro Superb RESTful support
Act makes creating RESTful service a kids game. It features AdaptiveRecord (allows front end to drive the data structure), JSON response control (just declare the fields you want to present or hide) and RESTful URL routing with path variables.
Pro Easy to deploy
ActFramework is not a servlet framework and there are no requirements on containers/app servers. It has a small package size (a helloworld distribution package size is less than 20 MB), a small memory feet print (a helloworld app heap usage is less than 20MB) and a fast boot up speed (a helloworld app starts in less than 3s).
Pro Templating
Act's view architecture is very flexible and support using multiple view engines in your app. The default template engine is Rythm, a very developer friendly and powerful template engine. Act also support other templating solutions including freemarker, velocity, thymeleaf, and mustache via plugins.
Pro Configuration for multiple environments
Act supports load configuration from a common dir and then overwriting it from a profile dir. Makes it very easy to manage configurations in different environments (e.g., dev, uat, sit, prod) Watch this video to see the innovative way Act delivers its configuration support.
Pro Concise and expressive
Act does not require you to put Annotation when it is able to infer the intention from other parts of the code, i.e., you don't use @PathVariable
or @RequestParam
to tell Act the binding parameter name. And you don't need a ModelMap
to bind variables to render argument names. Act has sophisticated byte class scanner to detect the variable names to do bindings automatically.
Pro Comply to standards
Act's IoC is built on top of Genie, a fast dependency injection library that fully supports JSR330, and Act's validation solution is built on top of JSR303. Act is NOT an odd framework to most Java developers. Unlike Play1.x, ACT applications follow the standard maven project structure and it is very easy to integrate other Java libraries.
Pro Database access
Act's DB layer is extremely easy to use. It supports SQL databases (through ebean orm) and MongoDB (through morphia). Using multiple datasource can never be that easy with Act's DB layer. Go here for more information on this.
Pro Fast and flexible routing
You can configure your routing in either Spring MVC/Jersey style with annotation or Play style with route table or a combination of both. Act's routing supports RESTful URL path variables, optionally validated with regular expressions.
Cons
Con Golang controlled by Google
Solves Google problems, which might not be your or the majority of user's problems. Was created for the benefit and purposes of Google, so is less flexible in language direction and options.
Con Hard to abstract even the simplest notions
Go is famously regarded as very simple. However, this simplicity becomes problematic in time. Programmers who use Go find themselves over and over again writing the same thing from a very low point of view. Domains not already served by libraries that are easy to glue are very difficult to get into.
Con Forces K&R style and won't allow Allman style
Golang developers were extremely short-sighted and biased by forcing the K&R style, which should never have happened. Basically kicking Allman style users out of their language.
Con Doesn't have true enums
Golang does weirdness with const versus having real enums, like other languages. This reflects the stubbornness and shortsightedness of the core developers, similar to the issue with generics, where it was denied that it was needed until it became too obvious that it should have been added years ago.
Con Does not have sum types
Makes it harder to have functions of different parameters types in a non OOP language. Thus messy generics and interfaces, and more confusion, where sum types could have solved a number of issues.
Con It appears Google uses position to snuff out or suppress other languages
Newer languages that could threaten Golang (or other Google controlled languages) appear to have suppressed search results on Google and YouTube. Dangerous situation where large company can manipulate user choice and market share. The freedom to freely choose and user rights need to be protected.
Con Designed to make the programmer expendable
Go was designed for large team projects where many contributors may be incompetent. That Go can still get things done under these conditions is a testament to its utility in this niche. Go's infamously weak abstraction power is thus a feature, not a bug, meant to prevent your teammates from doing too much damage. This also means any team member can be easily replaced by another code monkey at minimum cost. Good for the company, bad for you. The more talented programmers, on the other hand, will be very frustrated by having one hand tied behind their back.
Con Easy to shadow variable
Due to single character only difference, declare and assign statement can easily shadow variable from outer scope unconsciously. Example:
err := nil
if xxx {
err := somefunctionthatreturnsanerr
}
return err // always return nil
Con No forms designer
Those who are used to Visual Studio can feel the lack of a forms designer for rapid development.
Con Bizarre syntactic choices like a unique date format.
Con Changing visibility requires renaming all over the code
Con Lacks support for immutable data
Only way to prevent something from being mutated is to make copies of it, and to be very careful to not mutate it.
Con Performance slowdown because of indirect calls and garbage collection
Practically no meaningful Go application can be written without indirect function calls and garbage collection, these are central to Go's core infrastructure. But these are major impediments to achieving good performance.
Con Implementation of interfaces are difficult to figure out
Finding out what interfaces are implemented by a struct requires a magic crystal ball. They are easy to write, but difficult to read and trawl through.
Con Incomplete microservice support
Although Act is built to be a great framework that supports microservice development, it lacks some of the key features at the moment, like sending requests to other microservices from within the app, service governance, and messaging handling.
Con Very small community
As of February 2017, Act is a brand new framework (even though the project started at the end of 2014). Community is still forming.
Con Functional testing support still under development
Developers are still working on innovative functional testing support for Act.
Con Documentation is still being written
Act's documentation is still under development.