Monthly Archives: November 2015
Just started reading the book (2 chapters), but it seems to contain various good insights.
The reactive systems are gaining popularity these days along with the trends in computing like hardware (cpus/cores architecture) and software (granular computing resources – virutal machines or containers).
The reactive systems provide scalability and resiliency, and the need to be designed from ground up. The traditional synchronized processing fundamentally limits the scalability of applications and resilience to the failures. By designing the asynchronous processing on distributed computing resources in to the system, the handling becomes part of the scenario.
Some notes so far are,
- One difficult aspect of distributed system is caused by the partial failure instead simple all or nothing.
- Aiming for fault tolerance instead of just avoiding failures, are more reasonable approach, as completely avoiding failure cannot be fully successful. Providing resilience goes one step further from tolerance which aims for recovering to original state and functionality.
- Distribute and compartmentalize are the only generic methodologies to protect the whole system from failing. However compartments are not fully isolated, the failure can cascade and result in a whole system down (ex. partial failure overloads the system and chains into to the system down).
- Supervision is one way to provide resilient system. If the bending machine is broken, you will be calling the maintenance operator instead of trying to fixing by itself.
Just read the Kotlin book after listening to the Fragmented podcast with JetBrain engineer which mentioned in the previous post (Watching – Mouseless driven development).
I heard of the language several times, but didn’t have chance to look at it. This time, I made up mind to investigate more.
The Getting Started with Kotlin in 2 minutes is a good introductory video for understanding its syntax and behaviors. Kotlin works on JVM and its concept and syntax are mainly coming from Java, but also good parts of Scala or Groovy is incorporated and making it modern language.
Scala has powerful extension of type-safety and functional-programming, but it’s a little too complex. Groovy has concise syntax and good productivity on small programs, but it’s a little too loose to cause dynamic exceptions like NullPointerException. Kotlin seems going between the two, and if the balance is good, it may be worthwhile to dig in deeper.
Just watched a funny and interesting presentation on mouseless operation of IntelliJ, which was referenced at Fragmented podcast. There’re various good tips introduced for more efficiently operating IntelliJ products.
I love using IntelliJ for JVM-related programming and usually applying keyboard-centric operations, but this presentation realized me that I wasn’t fully utilizing its power. Search and navigation through keyboards are very powerful.