REST API Guidelines

15 March 2018

rest api

REST API is the most popular interface for communication between different component of the system. There are a lot of different common sense approaches to design RESTful API. Despite this fact it is always better to have something written as a reference to follow common principles during API design of the system.

Here I have collected some REST API guidelines and API References. It’s nice start point for your inspiration.

REST API Guidelines

My Favorite Podcasts

05 November 2017


I’ve been listening podcasts for many years. Mostly (99%) technical podcasts. Here is the list in my favorite order (Please note, some of them are not in English)

  • (RUS) DevZen: Very interesting. It covers broad range of different technical topics

  • (RUS) Scalaz Podcast: Podcast about Scala

  • (RUS) Radio-t: Tech podcast. Sometimes might be boring because it has a lot of blaming and trolling

  • (RUS) GolangShow: only #Golang, only hardcore

  • (ENG) The Ruby Rogues: broad range of topics, not only #Ruby

  • (ENG) Functional Geekery: A podcast on Functional Programming, covering topics across multiple languages

  • (ENG) LambdaCast: LambdaCast is a podcast about functional programming for working developers

  • (ENG) Mapping The Journey: interviews with famous people from IT

  • (ENG) The Chanelog: broad range of topics

  • (RUS) CTOcast: mostly interviews, tech podcast with different guests from different companies

  • (RUS) SDCast: mostly interviews, tech podcast with different guests from different companies

  • (RUS) non-technical podcast about life

  • (ENG) The Chariot TechCast: “The Chariot TechCast is an interview show that covers emerging and important tends in the world of software development.”

  • (ENG) Software Engineering Radio: different tech topics

  • (RUS) Razbor poletov: Java-related talks

Reflection about the next main scripting language

31 October 2017


I differentiate normal programming language and scripting programming language.

Scripting language must be used for quick prototyping, automation, has a nice integration with shell, etc. Also, it should be very quick at startup time.

So, any automation task can have the next implementations evolution, e.g.:

  1. bash script

  2. then any scripting language (Python, Ruby, Groovy, Perl, etc.)

  3. CLI application

I have been using several languages which have such characteristics (or similar): Ruby and Groovy.


I started using Ruby (as a scripting language) in 2008. It was cool. In that time Ruby community was "bashing" Java. The community was and is Ruby on Rails centric, mainly non-Windows. Almost nothing has happen outside of Rails (Vagrant, Chef and Puppet are exceptions), and it’s sad. But this language has a "soul". I could not explain, but I feel happiness while I am writing something in Ruby :-)


Groovy is nice JVM language which has own pros & cons. But now, this language has some problems with popularity (see The state of Groovy and other JVM Languages). And for me it’s a very important point. Also, due to JVM nature, the script startup is very slow (I do not count GroovyServ).

Groovy language syntax is much better for me than Ruby. I like Groovy packages and hate Ruby Modules and Namespaces. Again, it just a matter of taste.


If we compare different scripting languages they are almost the same in terms of what can be implement using them. But, some of them have community problems, some - ecosystem problems, some - is just not well suited to your development approaches (e.g Perl, Lua, Js/Node.js).

And as always there must be some shift or motivation to look around and try something new and hopefully better. The time invested in learning new "tool" must be rewarded in future.

If we look around the decision of picking another better scripting language is very simple - it’s Python. And by "better" I don’t mean syntax.


I have never used Python because Ruby (or Groovy) had the similar language features and I have not seen any benefits in switching to another language. On the another hand, Python has huge ecosystem, it has library for almost everything, it is not a framework-centric language (see Ruby on Rails, Groovy: Grails or Gradle). And the most important it has a momentum in terms of Data Science, Machine Learning and Artificial Intelligence (where I have big interests as the other people). Unfortunately, Ruby has lost this fight.

For several month, I have been using a lot of Python-based tools (AWS CLI, ZMON, Stups) during my work day and this is another big motivation for me to look into the Python as my potential next scripting language.

There is a very interesting moment. I do not like Python syntax (I am not dogmatic). For some reason Python syntax (and language features) is very ugly for me. And I would pick Python only because of pragmatism and not because I like it. But, I am not sure whether Python will be my main scripting language since Python is not equal to "happiness" :-(

Python is very popular right now (check the numbers below) and it’s a very good time to start using it if you don’t have biases like I have.

Languages Popularity Statistics


Figure 1: The RedMonk Programming Language Rankings: June 2017


Figure 2: TIOBE Index for October 2017


Figure 3: PYPL PopularitY of Programming Language

IEEE Spectrum

Figure 4: Interactive: The Top Programming Languages 2017

Stack Overflow

Figure 5: Growth of major programming languages


Figure 6: The fifteen most popular languages on GitHub (2017) by opened pull request

Reserved Words of Programming languages

28 November 2016


Amount of reserved words per programming language:

As You can see Golang has the minimal amount of reserved words.

C++ keywords: 92 words

alignas (since C++11)    dynamic_cast           reinterpret_cast
alignof (since C++11)    else                   requires (concepts TS)
and                      enum                   return
and_eq                   explicit               short
asm                      export(1)              signed
atomic_cancel (TM TS)    extern(1)              sizeof(1)
atomic_commit (TM TS)    false                  static
atomic_noexcept (TM TS)  float                  static_assert (since C++11)
auto(1)                  for                    static_cast
bitand                   friend                 struct(1)
bitor                    goto                   switch
bool                     if                     synchronized (TM TS)
break                    import (modules TS)    template
case                     inline(1)              this
catch                    int                    thread_local (since C++11)
char                     long                   throw
char16_t (since C++11)   module (modules TS)    true
char32_t (since C++11)   mutable(1)             try
class(1)                 namespace              typedef
compl                    new                    typeid
concept (concepts TS)    noexcept (since C++11) typename
const                    not                    union
constexpr (since C++11)  not_eq                 unsigned
const_cast               nullptr (since C++11)  using(1)
continue                 operator               virtual
decltype (since C++11)   or                     void
default(1)               or_eq                  volatile
delete(1)                private                wchar_t
do                       protected              while
double                   public                 xor
                         register(2)            xor_eq

C keywords

C89: 32 words

auto         goto         
break        if           
case         int          
char         long         
const        register     
continue     return       
default      short        
do           signed       
double       sizeof       
else         static       
enum         struct       
extern       switch       
float        typedef      
for          union        

C99: C89 + 5 words


C11: C99 + 5 words

_Alignas        _Noreturn
_Alignof        _Static_assert
_Atomic         _Thread_local
_Generic        _Noreturn

Python 2: 31 words

and       del       from      not       while
as        elif      global    or        with
assert    else      if        pass      yield
break     except    import    print
class     exec      in        raise
continue  finally   is        return
def       for       lambda    try

Python 3: 33 words

False      class      finally    is         return
None       continue   for        lambda     try
True       def        from       nonlocal   while
and        del        global     not        with
as         elif       if         or         yield
assert     else       import     pass
break      except     in         raise

Ruby: 41 words

__FILE__  and    def       end     in      or      self   unless
__LINE__  begin  defined?  ensure  module  redo    super  until
BEGIN     break  do        false   next    rescue  then   when
END       case   else      for     nil     retry   true   while
alias     class  elsif     if      not     return  undef  yield

Golang: 25 words

break        default      func         interface    select
case         defer        go           map          struct
chan         else         goto         package      switch
const        fallthrough  if           range        type
continue     for          import       return       var

Java: 53 words

abstract    continue   for         new          switch
assert***   default    goto*       package      synchronized
boolean     do         if          private      this
break       double     implements  protected    throw
byte        else       import      public       throws
case        enum****   instanceof  return       transient
catch       extends    int         short        try
char        final      interface   static       void
class       finally    long        strictfp**   volatile
const*      float      native      super        while
false       true       null

*       not used
**      added in 1.2
***     added in 1.4
****    added in 5.0

Scala : 50 words

abstract    case        catch       class       def
do          else        extends     false       final
finally     for         forSome     if          implicit
import      lazy        macro       match       new
null        object      override    package     private
protected   return      sealed      super       this
throw       trait       try         true        type
val         var         while       with        yield
_    :    =    =>    <-    <:    <%     >:    #    @

Scala’s special symbols (_ : = => <- <: <% >: # @) can be excluded and in this case Scala might have only 40 reserverd words.

Older posts are available in the archive.