Curious Programmer

Producer/Consumer - any application that wants to produce/consume message

Topics - logical concept

Partitions - Physical commit logs of topics

broker === server (kafka-server.sh)

replication-factors - # of copies to be made for redundancy

ISR — In sync Replicas (determines the health) Health of the system is good if # of replica==ISR #

When producing messages, the essential properties are:

 bootstrap. servers — which specifies the list of brokers to be tried out

 key serializer

 value serializer — both of which are normally string serializers

The pseudo code is as below

   KafkaProducer kp = new KafkaProducer(props);

   kp.send (new RecordProducer(“topicName”,”key”,”value);

Comm command is really handy for checking the file differences

In simple terms, the usage is: comm [-123i] file1 file2

Wherein -1 is suppress unique lines from file 1 etc

When using this command: 

docker run -p 27017:20000 -d mongo

it takes the mongo db running in the container port 27017 to the localhost port at 20000.

# Rename branch locally    git branch -m <old_branch> <new_branch>         

 # Delete the old branch git push origin :<old_branch>                   

The difference between decentralized and distributed is that a distributed system is a network consisting of autonomous computers that are connected using a distribution middleware. The components interact with each other in order to achieve a common goal. Decentralized computing is the allocation of resources to each individual workstation, on hardware and software. It means no node is informing any other node as what to do.

From Java8, its easy to make any execution parallel. But which scenarios one needs to use it. Lets do a simple experiment

concurrency: ability to do 2 or more things at the same time

Looks like the world is going from npm to yarn for better handling of packages

Use node to install yar

npm install -g yarn

Then use yarn to manage the packages

yarn add global yo 

Recently I came up with sdkman.io which is more like a version manager for java, scala, groovy, maven etc

Bitwise operators is one of the most under rated (under utilized) operators I would say. For eg. the bitwise shift operators can be used for multiply/divide by power of 2. i.e.

Above is true for arithmetic right shift operator is >>, but the logical right shift operator is >>> does not follow to this rule..The main reason being: a shift right logical, moves zeros into the high order bit (MSB).  But at the same time,  arithmetic right shift replicates/retains the sign bit

With the recent release of Java comes the long awaited feature of REPL. I have been a fan of REPL esp with Scala.

So installed Java9 explored the options.

Following is the condensed version/notes of all my experimentation so far

Every execution in REPL is called snippet and you invoke it by calling jshell from $jdk9_home/bin

/list -all -start (stat snippets)

Other options are

/imports - lists all the imports so far

/vars - lists the variables

/methods - lists the methods

/type - lists the classes created

One good thing REPL supports both forward and backward referencing. i.e. You can create a method taking Foo object even before creation of Foo class

Some of the repetition snippet options are:

/! - return last snippet

/-{n} -return n-1th snippet

/{n} - returns nth snippet

/edit - opens an editor (good for creating classes)

/save -all {filename.sh} - store all the snippets

/open fn.jsh - open the filename snippet

REPL supports the following startup options.

DEFAULT, 

JAVASE, 

PRINTING

For eg:

  jshell —startup DEFAULT —startup PRINTING

with that you can type the following instead of regular System.out.println(1+1)

print(1+1)

One good thing is about the optional ; though ;-)

To load the jars into Classpath use the below

jshell —classpath gson.jar (outside, when invoking jshell)

/env —classpath (inside jshell to load cp)

As a good shorcut, use the following to clear the contents of REPL

ctl_l — clear

You might wonder how REPL can be used for a regular Java Engineer.

But think of some scenario wherein you wanted to try a Regex for a string

Earlier the options are limited and lengthy and now its as breezy as below:

“abc”.matches(regex)

I was coming up in a random internet article for solving all permutations of a string or in simple terms all possible combinations of letters in that string. I see this as a recipe for recursion and came up with below solution. Spoiler: the code is in java.

public static void permutation(String str) {

     permutation("", str);

 }

 private static void permutation(String prefix, String str) {

     int len = str.length();

     if (len == 0) System.out.println(prefix);

     else {

         for (int i = 0; i < len; i++)

             permutation(prefix + str.charAt(i), str.substring(0, i) + str.substring(i+1, len));

     }

With the recent release of Java 9 and esp to try the long awaited feature of JShell, I wanted to try that. But still the project am currently engaged is using Jdk 8. I just wanted to ensure smooth transition between Jdk 8 & 9 and came up with the below aliases

alias j8="export JAVA_HOME=`/usr/libexec/java_home -v 1.8`; java -version”

alias j9="export JAVA_HOME=`/usr/libexec/java_home -v 9`; java -version”

With Jdk 8 being default for my project use. Whenever I wanted to use j9, I can simply say j9

And Btw to trigger a jshell also I have the following alias set

Recently one of my friend who is a budding (?!) SRE came up with this requirements. He is a Mesos guy and wanted to put some utility to replace json values through command line so that he can put in an ansible playbook. Challenge accepted. :)

Even though I work heavily on JEE with JSON payloads, changing the json via command line is something new to me. Initially thought of using jq (http://jqplay.org) and successful but it might be bit cumbersome to get added into ansible playbook. Hence thought of checking with my old mates sed and awk. Am not claiming myself an expert sed/awk though I use occasionally in my servers. Interestingly sed can be used for this with \1 and \2. My co-worker was asking about this (hence this article). In sed, \1 and \2 holds the placeholders for the grepped items in the matching section so that they can be used.

For eg., in my friend’s issue of replacing value in an json (here he wants to replace the value for the json key “type”). So the below mentioned sed command is used. Here \1 holds the value of “type”: and \2 holds the string of whatever comes after value. Like {“type”: “mesos”}, \1 is the “type: ” and \2 is empty since after "mesos"

For long I thought both of them are same. But with recent blog post from random internet article proved otherwise.

Observer pattern is where the observer knows the subject from whom he is listening to

But in pub-sub pattern, publisher doesnt necessarily need to know the subscriber and vice versa. They interact normally through a message broker or event bus