Category Archives: Conference

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.

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.

Keynote – from José Valim

Recent history of extended elixir capability, and coming future enhancements.

The recently added mix profile.fprof provides nice and easy interface for profiling. The fprof of erlang is somewhat cryptic and difficult to start using. The new ex_doc styling is getting nicer, along some other improvements.

Also, the coming future features like pipeline parallelism and GenRouter will be more extending the capabilities in parallel and distributed system, which sounds promising.

Keynote: Elixir Should Take Over the World – from Jessica Kerr

It might be one of the best talk with insightful ideas and encouraging statements. It introduces the power of elixir by comparing with historical progress in physics. It’s an insightful talk about how progress is being introduced, and how it relates to computer and programming architecture. The history shows always new ideas are coming and we need to keep thinking about what’s coming next.

which is enforced by the related ideas and technologies coming in this age. One remaining part is the People to spread the idea to the world, which elixir is improving at the moment. Elixir is providing different paradigm and it imposes certain difficulty, and sharing various types of experiences at different levels helps new-comers to improve themselves.

Just happened to find the presentation about live code updates on JVM, and was looking around it. I was knowing of the live reloading which some web frameworks provides, but didn’t know about the live updating of the codes while maintaining the state (variables, etc.).

The above presentation at twitter was implementing the dynamic class/method dispatching architecture by introducing additional layers into class hierarchy. It’s interesting approach, but introducing the layers seems to exposing the complexity, especially when states need to be updated or when reflections are involved. If it becomes open-source, it might be worth trying out.

The related article covers interesting topic too. The dynamically loading new classes can cause hidden chain in the class reference which fails the garbage collector to dispose the unused objects to be maintained in the heap.

Erlang is famous for live-code updating, and will be looking around the differences.

A nice presentation about immutability from clojurescript creator. Immutable data structures are getting more attractions along with the popularity of functional programming language. The presentation covers related trie data structures and its advantages in performance along with new immutability-based platforms like Elm and React.

I used to be struggling on ruby’s clone method regarding performance and complexities in deep/shallow copy, but now I’m loving immutable data structures and tail-recursions while playing with elixir. When programming with ruby, I started to use hamster gem lately. It works nicely, but lack of tail-recursions sometimes painful.

Some watching notes of the above talk. Mostly about first-half of the talk. second-half is more conceptual and couldn’t understand enough.

[Around 8:00] Microservice concept affects the team structuring. Instead of having technology oriented team structure like UI, Server and DBA, cross technology members can build a team which responsible end-to-end relatively smaller service product.

[Around 8:30] The historical SOA (Service Oriented Architecture) is somewhat similar concept as Microservices, but SOA was focusing too much of smartness in the center of communications which leads to complex structures. Instead, Microservice tries to put the small set of smartness in each endpoint. What’s required is the powerful communication channel between endpoints.

[Around 12:00] Infrastructure automations are required for managing many services, with continuous integration or green/blue deployment technologies. Without this backbone, Microservice approach will fail.

[Around 14:30] What’s the difference between Microservice and SOA? SOA has too broad meaning, and Microservice concept can be considered as useful subset of SOA.

[Around 17:00] How big the Microservice should be? Many organizations are reluctant to answer this question straight. Actually, asking how many people are involved in a service results in wide variety of answers. It’s difficult to find one solution, but amazon’s 2 pizza team is a good notion.

Just watching some presentations from dockercon, and this one from Netflix architect nicely describes the trend of cloud architectures.

Some notes are,

(3:00) The adoption of cloud is growing faster, and docker was growing even faster. Docker was not in anyone’s 2014 roadmap, but it’s in everyone’s 2015 roadmap.

(8:00) The silo’s of development teams. Just having cross-structured product team is not so efficient. Service/API based infrastructure with DevOps concept is good for optimizing the product development pipeline.

The feature sets around the S3 are getting mature and mature. The event notification and lambda calculation around data store sounds compelling. The computing unit is getting more and more granular and flexible. From the virtual machine, it’s divided into an application and then simple function + datasets.

The demonstration (around 25:00) of photo data conversion is interesting. Real time and simple calculation which is available across any platform. It’s nice.

A nice presentation about learning from failure. Acting smart and keep being successful can make people afraid of mistakes. If you’re not accustomed to failure, you may get anxious when facing risks.

The figure described at around 25:00 sounds nice.

praise effort

expose ignorance

safe to fail

Admitting ignorance is sometimes difficult, but it’s a start point of improvements. Embracing the risks on challenging helps the improvement process, and the atmosphere to praise the effort in addition to the results itself can create the safe place to fail and quick iterative improvements.