Michael Koltsov's den

Go in Practice is a nice small book that in my opinion should be the starting point for every Golang programmer. As the language is so small you can learn it in a few days, but its libraries are its biggest value if you ask me and this book tries to explain why those libraries have allowed to scaffold such projects as Docker and Kubernetes.

The book is boring sometimes, it goes in too much detail without a particular need. Explaining the methods of this or that class is too much of a burden for the readers in my opinion.

The biggest flaw of the book is also its biggest virtue. Even though I had no problems with running some of the code that's embedded in the book ( the version of the book in Safari is awful BTW) as the book promises to be a practical guide some the solutions to the problems the the author thinks one can face are a bit outdated. If you claim to give practical solutions than you need to update your book with the best solution that's currently available

My score is 4/5

VueJS is the new kid on the block, though it might look familiar to most of frontend developers who had experience with Angular 1.x prior to that. And that's not an coincedence due to that VueJS author was one of the former core contributors to Angular therefore he claims that he took the features that we of the most importance to community and got rid of the unneccessary complexity that Angular 2.x presents as its features.

I can't agree more on that. For me as a former Angular addict VueJS looks like a breath of fresh air in comparison with React. React was a good thing in its times, it helped to educate frontend engineers who usually lack formal CS education therefore are prone to reinvent the wheel with every project they touch. React has brought a lot of fundamental CS concepts like immutabilty and referential transparency that they called "pure functions" to the attention of the Javascript developers. But if you're not a frontend developer than React will take a heavy toll on you as in my opinion it makes creating a simple app unbearably hard as you need to learn JSX, Redux and other things just to start. React ecosystem changes so quickly that it's not worth the effort to enter it as it could change at any moment.

Here VueJS comes into play. It has adapted some of the most valuable React features which is Redux in my opinion, but to write a VueJS app you don't need to know anything besides Javascript and HTML. It's unbelievable, but you don't even need NodeJS to write a frontend app in Vue.

Ok, let's go back to the book. The book is great, I can't say more about it. It reminds me of the Head First book series that was iconic to the IT newcomers back in the mid 2010's. Olga reminds Kathy Sierra a lot as they have a similar narratory style though Kathy usually gets in too much details as she expects her readers to have zero knowledge and Olga sometimes skips some of the concepts and gives a referrence to the book's complementary source code. It's hard to find it therefore I've made a fork that's will be more accessible for anyone https://github.com/mkoltsov/Vue.js-2-and-Bootstrap-4-Web-Development

The book gives a lot of practical examples on how to start writing actual webapps with Vue, it even goes to such extent as how to deploy it and manage its data.

My score is 5/5

I always thought of myself as of a quick learner, therefore I prefer to practice and hone my skill rather than reading long and lenghty books.

But this book is an exception. It’s not long, it’s not boring. But after reading it I felt unsatisfied as the code examples were far from what’s needed in the real life, some parts of the language are shallowly described and the whole impression of the language it gives is that Go is very close to Javascript and you can easily learn it over the weekend.

Unfortunately, that’s not the case with Go. I’ll give a try to “Go in Practice” from the same publisher in a hope that it will not leave me with lots of unanswered questions as this book did.

My score is 2/5

Ruby (along with Python and Javascript) is a kind of a language that allows you to use it without dropping a sweat to study it. That’s what has happened to me. I’ve been using Ruby for a while, but haven’t read anything but blog posts about it.

This book gave me a good momentum to start using some of the Ruby features I (i.e. Fibers ) that I was  completely unaware before, though the amount of input it provides is not overwhelming which helps you to digest this book over a weekend.

That’s a good starter for anyone willing to start coding in Ruby 2.1, lots of examples are outdated if you aim for Ruby 2.4+

My score 4/5

This is actually the first book about Python I’ve read even though I’ve used it extensively throughout the years.

My perception that this book proves is that Pythonistas are usually not programmers by trade, they’d come to programming either due to a lucky coincidence or by taking a wrong turn on the road of career hopping.

This book has promised to give a broad look on the Python’s ecosystem, it actually delivers on what it promises. But this look is so shallow that I can’t recommend this book for those who’s willing to get a deep dive into Python on a weekend. The technical details it gives look like author’s waving the hands in the air with no actual proof that I’m used to in Scala and Java books.

Good book, but I can’t recommend it to any professional programmer who’s used to technical/programming/mathematical books.

Score 3/5

This book is considered a cornerstone of the DevOps movement. In my opinion, it might be that in the very beginning, but currently most of the concepts that it presents are obvious and outdated.

I will recommend it to be read to someone who’s new in the DevOps community, but if you’ve got a few years of experience in the area under your belt I would   not.

It’s nice to have all good concepts under one cover, but reading a 400-pages long book that will tell you the history of GIT and SVN is pointless in my opinion. Most of the ideas presented in the book could be wrapped in one long yet succinct blog post.

My score 3/5

This book actually reminds me of the book “Release it ” but with much less emphasis on actual technical patterns but with a stronger accent on soft skills.

It’s also complimentary to the “Phoenix Project” written by the same authors.

If you’ve skipped the “Phoenix Project” or you don’t like to read the novels, like I do, I would recommend you to start with this book as it has much more momentum than the first book.

It has a bunch of great inspiring examples of successes from the companies that have embarked on the “DevOps journey” which to me is the best part of this book. Also the book is relatively recent therefore a lot of its advices are quite innovative and might be even disturbing to some.

My score 4/5

Sometimes I’m late for some of the most important events in my life. Hopefully, health is not the issue that I’ve missed. Self-awareness and consciousness have always been a nice thing to have under your belt.

This book helps to improve those skills by giving you a nice reference for all the good things you need to be aware of that might either help you to advance or suffer as a human being.

This book is nothing more than a composition of blog posts, though it gives your a nice system as a set of goals you can follow along with a companion mobile app. In my opinion, it’s much nicer to have good ideas under one cover than scattered around the Internet.

My score 4/5 due to how actual this topic is for myself

There’s a relatively short list of books I would like to keep on my desk. Most often those books are references and a composition of famous quotes. After I’ve read this chap I’d like to have it on my work desk at any moment.

This book is a perfect mix of lots of useful technical insights, practices and recommendations got from the author’s hard-earned experience combined with some of the soft-skills you need to make your software and its maintenance (which as the author states costs more than the initial 1.0 version) as smooth as possible with as much of interrupted sleep as you could possibly get.

The book is definitely outdated, some of the references to particular technologies look odd and obvious (if not even funny). Nevertheless, I will put this book in one row with the “SRE book” & “Project Phoenix” as it combines them both.

My score is 5/5

That was the first non-technical book I’ve read for the last few years. At first I was really struggling to go through the first one hundred pages as I was constantly bored due to absolute lack of any technical details. However, a good book is always a good book even though it’s an IT-concerned novel.

What I like in this book is how it reminds some of the actual projects I’ve worked. I’m not sure whether the final solution that this book presents will be suitable for anyone but still it gives a lot of food for thought how to improve the inner processes and the workflow in any IT organization. If you like “The Deadline” by Tom DeMarco you would love this book.

My score is 3/5, simply because I don’t like novels.

Abstract

Java 9 is supposedly coming in July this year. All of its features are already discussed, however, as it was in the past everyone will wait until the minor version 1 or even 2 will be released for the wide adoption to take place. What’s even more important that usually OpenJDK community doesn’t care a lot about the JVM languages if it’s not Java. Those Clojure developers who used to install every JVM update know what I’m talking about.

Let’s quickly reiterate what are the major JVM/Java features that might affect (or have already affected, according to the current b168 build) Scala and its ecosystem as Scala has currently its prime-time with a lot of business users unwilling to break their core apps due to a new version of the platform its built upon.

In my opinion the list of features should look like that:

• JShell
•  Compact strings
•  Variable type inference
•  Factory methods for making immutable collections
•  ECMA6 features in Nashhorn
•  Http/2 client
•  Private methods in interfaces
•  Reactive streams
•  Multi-release jars
•  AOT Compilation
• G1 Garbage collector
• Modules

Let me quickly go through that list one by one to explain what in  my opinion will be the pros and cons of every feature.

JShell

If someone still recalls what was the BeanShell back in the days when there still was a need to write scripts in java due to lack of robust scripting language for the JVM let me assure you that’s not it though a full-rethought fork of it that has gone through multiple JCP improvements. It’s not as versatile as running

 sbt console

on your project with all your dependencies and Scala code compiled being already added to the classpath, but hopefully Java build tools could improve that and make this REPL as useful as it is  for Scala projects.

import java.security.Security

Security.setProperty("crypto.policy", "unlimited")

Notice the lack of semicolons, but be aware that you still need to use them if you plan to write a function.

void println(String arg) {
    System.out.println(arg);
}

println("Hello Java")

Compact strings

Did you like that every string is a char array? I didn’t as even considering a string pool having a lot of strings was costly, made your heap unnecessarily large and  made your unicorn garbage collector cry since why should it be bothered with cleaning of … strings?

GC has to stop the world due to abundance of strings

Since JDK 9 your strings will become… arrays of bytes plus an encoding flag.

According to findings made by the JDK committee the lower footprint will make your unicorn garbage collector dance of joy.

The GC is waiting for more garbage

Let me illustrate it with a slide from a great presentation done by Aleksey Shipilev at JFokus.

Variable type inference

You’re finally allowed to omit the type while allocating a new Java variable, like you know… in Scala.

var myCounter = 0L

val myName = "Adam"

Sorry, just kidding. It’s not yet there. It’s the most anticipated JEP for me personally that was proposed last year by the JCP, even though it was authored by Brian Goetz there’s no final decision yet will it be a part of Java 10 or Java XXL (the one that will implement generics in a real type safe way rather than with type erasure).

Factory methods for making immutable collections

One of the most loved and hated Scala feature is its collection library. In case of JDK 9 it has nothing to fear about. Making immutable collections have become less tedious, though the choice of factory methods instead of constructors is questionable if you ask me. The most frequent use case for Google’s Guava (apart from the magnificent CacheBuilder which we often use with Scala) is fully covered now by the Java core functionality in my opinion.

List immutableList = List.of();
List<String> immutableList = List.of("1","2","3")
Map emptyImmutableMap = Map.of()
Map nonemptyImmutableMap = Map.of(1,"one",2,"two",3,"three")

ECMA6 features in Nashhorn

We use Nashhorn and JVM-based scripting quite often, therefore having ECMA6 features like arrow function and block scope will be very helpful.

Unfortunately, in every JDK9 build I tried I couldn’t find features promised in the corresponding JEP.

Let me list them so we could hope to see it in the near feature with a minor update.

Promised during the initial update

• Template strings
• let, const, and block scope
• Iterators and for..of loops
• Map, Set, WeakMap, and WeakSet
• Symbols
• Binary and octal literals

Promised with later updates

• Arrow functions
• Enhanced object literals
• Destructuring assignment
• Default, rest, and spread parameters
• Unicode
• Subclassable built-ins
• Promises
• Proxies
• Math, Number, String, and Object APIs
• Reflection API
• Classes
• Generators
• Modules
• Module loaders
• Tail calls

Http/2 client with websockets

Though not as useful as Spray-can and its later reborn as Akka-http-client this version of out of the box http client for Java has finally managed to use Http version 2 as well as WebSockets. This is really helpful as it will allow to get rid of nasty includes of Apache Commons and Spring for the single purpose to do a http call… like we do in 2017. Did I say that it also has an asynchronous API?

import java.net.http.*

import static java.net.http.HttpRequest.*

import static java.net.http.HttpResponse.*

URI uri = new URI("http://grandparade.co.uk/blog")

HttpResponse response = HttpRequest.create(uri).body(noBody()).GET().response()

System.out.println("Response was " + response.body(asString()))

Private methods in interfaces

This is the feature that looks to me as an attempt to chase the  Scala’s trait features. In addition to the default method implementation in interfaces added in JDK8 this is the second step to make mixins available for Java developers.

This is very handy for those who need to switch between Scala and Java quite often (like I do).

public interface Bear {
  private Long iterateTeeth() {
      return 42; 
  }
  private static void makeARoar(){
      System.out.println("GO BEARS GO!");
 }
}

Reactive streams

I’m not exactly sure how this feature will be adopted by the Java developers as we’ve seen a lot of traction towards JavaRx amongst them. Although lambdas provided by JDK8 allow to follow the reactive manifesto in Java easier than before, it’s still a long way to go to do this in Java

val o = Observable.interval(200 millis).take(5)
o.subscribe(n => println("n = " + n))
Observable.just(1, 2, 3, 4).reduce(_ + _)

However, this is also fine written with the Flow API provided by JDK 9

import java.util.concurrent.SubmissionPublisher;  
...  
    //Create Publisher  
    SubmissionPublisher<String> publisher = new SubmissionPublisher<>();  
  
    //Register Subscriber  
    MySubscriber<String> subscriber = new MySubscriber<>();  
    publisher.subscribe(subscriber);  
  
    //Publish items  
    System.out.println("Publishing Items...");  
    String[] items = {"1", "x", "2", "x", "3", "x"};  
    Arrays.asList(items).stream().forEach(i -> publisher.submit(i));  
    publisher.close();

Such primitives of the Flow API will be given during the initial release:

• java.util.concurrent.Flow
• java.util.concurrent.Flow.Publisher
• java.util.concurrent.Flow.Subscriber
• java.util.concurrent.Flow.Processor

Multi-release jars

By releasing multi-release jars Java committee is planning to address the pain you have to go through while upgrading a JVM version by providing compiled classes for every JVM version they might be executed on.

jar root
  - A.class
  - B.class
  - C.class
  - D.class
  - META-INF
     - versions
        - 9
           - A.class
           - B.class
        - 10
           - A.class

Let’s say your API has been compiled with the JDK 10, but for those retrogrades who are still using JDK 9 you can provide their own oldschool version of your class inside your jar file with no effort from the user’s side.

This feature makes my unicorn very happy.

AOT Compilation

This feature addresses those apps that have grown so massive that the JIT compiler takes time to warm-up and fill its caches. The idea is to have your code already compiled to bytecode before  starting your application to make the bootstrap of both big and small apps as agile as it could possibly be.

//first you compile it with the new jaotc compiler
jaotc --output libHelloWorld.so HelloWorld.class
//Then specify generated AOT library during its execution
java -XX:AOTLibrary=./libHelloWorld.so HelloWorld

There’s a lengthy thread on HN that explains all pros and cons of that feature, but during my small experiments I haven’t noticed any big difference. Scala compiler still takes the longest time to finish its compilation process in comparison with javac and jaotc. Theoretically, this feature might be a game changer for small apps like test Java packs that are eager to start as soon as possible with no need to wait until the caches get warm.

G1 Garbage collector

G1 collector has been added some time ago, so now after a long improvement & refinement process, it’s going to be the default GC as well as it’s one of the only two that are available for the jaotc compiler.

In my personal experience not having to think about what GC you’re using and which options of it to tune to get the most performance is actually a great thing as it allows you to stand on the shoulders of giants.

In my personal experience G1 makes the smallest GC pauses as well as it has the most throughput in comparison with parallel and CMS garbage collector.

Modules

One of the most awaited features of the new JDK is the “Jigsaw” project that was promised to use since java7 six long years ago.

JDK 9 will introduce such parts of it:

• Modular JDK
• Modular Java Source Code
• Modular Run-time Images
• Encapsulate Java Internal APIs
• Java Platform Module System

The bottom line is that you will be able to release your app in multiple jars by splitting it into modules and encapsulating each one into its own file. The JDK9 itself will be released in 92 modules (this number may change for the final release).

Unfortunately, sbt and scalac don’t support modules at that moment.

###

I was given this book, which is an uncommon event for me as I usually buy all books by myself. Moreover, I was given a paper version of the book.

Therefore, there were absolutely no regrets regarding this book =) The book is concise and covers almost all parts of Ansible I’ve ever heard of. The only exception was the case when you need to deal with a server that’s under a jump host/bastion, which is very common for cloud deployments as they usually are done in a VPC network of some kind that not exposed to the outer world.

This book has plenty of handful examples, but the most useful thing in it were not them.  The book covers some of the most undervalued parts of the Ansible ecosystem: Ansible Galaxy, Tower and it also has a decent set of invaluable pattern and best practices for writing your playbooks.

My score: 5/5, I’m not sure if you need to read anything more than this book if you plan to use Ansible professionally.

The book provides only a shallow knowledge of Puppet, doesn’t cover some of the most important modules you’ll need in the real world as well as it doesn’t provide practical examples.

I will recommend it only if you need to quickly brush up the technical details of Puppet’s architecture or you need to start using it quickly rather than spending some time on playing with examples its documentation provides

My score: 3/5

― Chris Hadfield{.authorOrTitle}, the first Canadian office on board of ISS

I can recommend this book only to those who’s looking for a very shallow knowledge of Mesos. It covers only the basics, no details, no iternal APIs, a lot of references to the Mesos documentation.

It’s worth reading if you need to quickly refresh your knowledge, besides that it’s worthless. It recommends to do Service discovery within the Mesos cluster by means of HAProxy & Mesos-DNS!!!

My score 3/5, RTFM