Profile cover photo
Profile photo
Markus Kohler
Markus's posts

Post has shared content
Java performing poorly with regards to latency. That is IMHO a bit surprising. 

Post has shared content
tag is a lightweight wrapper around ag that generates shell aliases for ag matches. tag is a very fast Golang rewrite of sack.

tag normally only supports ag a very fast file search tool. I developed a pull request for pt ( a very similar search tool but written in golang (ag is C code) that introduces the --null option, which is used by tag, but is also useful in other situations (xargs -0).
With the latest release you can now use pt with tag. See
Hopefully tag will soon support pt out of the box. 
Animated Photo

Post has shared content

Post has attachment
There is a now a
(basic) heap viewer in Intellij based Android studio
which includes dominator tree support!

Six years ago I loaded the first heap dump into the Eclipse Memory Analyzer:

Time goes by so fast ...

Post has attachment
some good points about microservices not being a silver bullet (of course), but with regards to
"I've also heard arguments that say that as a system increases in size, you have to use microservices in order to have parts that are easy to modify and replace. Yet there's no reason why you can't make a single monolith with well defined module boundaries. At least there's no reason in theory, in practice it seems too easy for module boundaries to be breached and monoliths to get tangled as well as large."

I have some comments. 

Practically there are reasons why you have to split into smaller servers.
1. Most runtimes do not support more than one version of the same component to be used with the same process.OSGI on Java does to some extent, but it never gained enough traction. I think the reason is that being able to load more than one version of a component only solves a small part of the problem. You still have to figure out how to handle incremental updates, how different versions of code talk to each other etc. 

 For that reason updating dependencies becomes very painful, because everyone has to do it at the same time. In some sense Amdahls law( applies here, because you have a global synchronization point. 

2.  Resiliency against failures can be easily increased with more services, because a services process that crashes does not crash the whole application. The operating systems takes care of this protection and people are free to use whatever runtime environment works best for them. Of course this kind of isolation could also be moved to the runtime, darts isolates come to my mind, but this technology is certainly not mainstream yet and one would be constrained to runtimes supporting this.  

3. Building a monolith quickly (incrementally) can be very challenging and the technology to support it has not yet reached the mainstream.
You want a build tool that supports incremental builds very well and does support a distributed build cache  (like googles blaze does for example). In the near future we might see progress in this area with bazel being open sourced and facebooks buck being available since some time and gradle to also attempt to solve this problem
Small services on the other hand often be build fast enough with a simple full recompile. 

Post has attachment
MAT (the Eclipse Memory Analyzer)  is still alive after almost 10 years! Finally someone (Square) built a commandline tool for automatic heap dump inspections. It's based on one of the MAT forks. I wasnt aware that there are several forks of MAT already out there. 

It's kind of funny, because MAT, internal code name "Digger" started as a command line line tool :-)

Post has attachment
Wait while more posts are being loaded