DEV Community: vikrampawar

Feature toggle/flag

vikrampawar — Wed, 17 Jun 2020 20:35:01 +0000

It's the idea of having a bunch of ifstatements in your code to turn a new feature 'on' or 'off'. It sounds a bit crazy when we put it that way, but it has a useful function.

This technique is used to push a new feature to production and test it by turning the feature 'on' for a small subset of your users. This is used in continuous delivery environments to deliver code to production as soon as it's ready, but at the same time reduce the impact if it doesn't work as expected, or, has a bug that can manifest only in production environment.

Once you gain confidence that the feature is working for the small subset of users, you gradually expose other users to the feature.

A slightly more advanced version of this was done by GitHub. They built a tool called Scientist which allowed them to compare the output of the new feature against the output of the existing feature and log the difference, but use the old feature to serve the user for now. Later, they went through the log to understand if the differences seen were expected ones or not. After seeing a sufficient number of these logs, and when their confidence in the new feature was established, they turned this feature 'on' for everybody.

Efficiency and Abundance

vikrampawar — Tue, 16 Jun 2020 21:44:47 +0000

When you have scarcity, efficiency is a virtue. It allows you to make the most of your resources. However, if you have abundance, efficiency is no longer a virtue in the same respect.

Efficiency is hard. It is unpleasant to be efficient. It requires a lot more discipline. So, efficiency is rare. We are not efficient if there is no compelling need. That is, we abandon efficiency, as soon as we understand that efficiency is no longer making the difference.

Now, let us see where these ideas make sense. In the early days of computing, resources were limited. So, efficiency was important. People tried to save resources every way they could. So, a lot of applications that were developed were developed with razor sharp focus on not wasting any resource, i.e, everything was made as efficient as was possible. So computing or developing software was not pleasant, not many people could do it, or wanted to do it.

But as computing resources became cheaper, and abundant, there was no longer the need to be very efficient in many types of development. It was okay if your program consumes 10 times, 100 times more memory, or disk space, or it does totally unnecessary work, many times over. It became possible, easy, and pleasant to write software this way that met the real needs of business.

What is a Message?

vikrampawar — Tue, 16 Jun 2020 20:11:08 +0000

What is a Message?

Here is a good definition of a Message.

I want to develop your intuition about a Message, so I'll elaborate this concept.

Message is an overused word. I want to develop intuition about a Message as used in Software Development.

Now let us suppose two people Alice and Bob want to communicate. If Alice shouts at Bob, we can't say Alice has given a Message to Bob. If instead, Alice tells Charlie something about Bob, and Charlie goes and tells it to Bob, we can say Charlie has passed on a Message to Bob.

What is the difference between the two situations? Of course, I introduced Charlie. But, Alice could have written the same thing in a piece of paper and sent that to Bob, or Alice could have sent an email or a text that has the same content, and in all these cases, we would say that Alice has sent Bob, a Message.

So, the fundamental thing that makes a Message a Message is that it leaves one person and then goes to another person. It has an independent existence outside of both people. And, because it leaves one person and then goes to another person, a Message by necessity needs to have the following information for it to be considered a Message.

It needs to have the information about where is it coming from, where is it going to, what is it about, and finally the actual content. These are called Sender, Recipient, Type (Subject) and Payload, respectively. The Sender, Recipient and Type are grouped together as a Header.

The same concept is used when information leaves one Application and goes to another Application.

An email, or a text, that we send is a Message. It has a Header, i.e, Sender, Recipient and Type along with the Payload.

A Message can be a lot more things, it can have a lot more information, but the Header and the Payload are the absolute minimum information that it needs to have for it to be able to leave one person or an Application, be independent, and reach the right Recipient.

What is a CIDR

vikrampawar — Mon, 15 Jun 2020 11:37:17 +0000

The Wikipedia link is here Classless Inter-domain Routing

And here is the basic information you need to know.

A CIDR identifies a machine connected to a network.

An example CIDR for IPV4 address looks like this 192.168.100.14/24.

The numbers 192, 168, 100, 14 are four octets. An octet represents 8 bits. We use four octets, so we are using 32 bits to represent the machine.

A bit can have two possibilities either 0 or 1. So, an octet can have 256 (2 ** 8) values, starting from 0 and ending with 255, which means 4 octets can represent 4,294,967,296 possibilities (2 ** 32).

But, the number after the / puts a limit on this.

Before, I explain how the limit is applied, I'll have to explain what number 24 means. The number 24 could also have been represented as 4 octets. If we did, it would look like 255.255.255.0. The number 24 is a compact way of representing these 4 octets. Are you wondering how these are equivalent? The value 255 when represented by a an octet (8 bits) looks like this 11111111. So 255.255.255.0 would be 11111111.11111111.11111111.00000000. I put . in between for readability. As you can see, this big number has 24 leading bits set to 1. That's the link between the two representations.

This number is telling us that while using the address 192.168.100.14, don't use the first 24 bits or the first 3 octets. That is, 192.168.100 are off limits. That leaves us with only the last octet, so only 256 possible values :( ! Imagine if this number was 31, that leaves only 1 bit or two possibilities.

The 3 octets that we do not use, along with a a 0 for the fourth octet 192.168.100.0 represents something called a routing prefix. If you represent this routing prefix in the form 255.255.255.0, it's called the subnet mask and logically represents the same thing.

Monolith/Microservices to Family/Company analogy

vikrampawar — Sun, 14 Jun 2020 23:21:38 +0000

Today I was reading Chris Richardson's book Microservices Architecture and it struck me that the Monolith to Microservices relation is analogous to that of a Family and Company.

Firstly, from a very high level view, both Monolith diagrams and Microservices diagrams have a bunch of boxes with various connections between them. What is the fundamental difference between them? The main difference is how the boxes are related. The boxes in the Microservices talk to each other only via Interprocess connection. Every other difference between the two architectures stems from this basic difference. There is no such restriction in the Monolith.

If you consider a family business run by a close-knit family. They generally tend work very efficiently as a group and accomplish a lot more than a group of strangers. There are many reasons for this, but the primary reason is that they have a very strong informal communication amongst themselves.

This works really well up to a point. If the business grows beyond the capacity of the family, they need to get outsiders to help them, Then things change. Their existing communication patterns won't work. They'll have to develop some formal ways of interacting with the outsiders. Once these formal ways are developed, then they can bring in a lot many outsiders and accomplish a lot more. People can be easily replaced as well. They can become a much bigger company.

Similarly, the communication between the boxes in a monolith are easy and don't require too much formality. However when the communication is constrained between boxes as in Microservices where it is forced to happen via Interprocess communication, it needs to become a lot more formal. The communication has to be via formal contracts. So the boxes become independent. They can be replaced with other boxes. More boxes can be brought in.

So, although communication between any two entities is constrained and formal and therefore poorer, it paves the way for the system to grow larger.

DEV posts on Stackbit

vikrampawar — Sun, 14 Jun 2020 15:09:04 +0000

I followed the DEV post to build this site.

Now, any posts I write on DEV will be automatically published to that site.

I did all this on an iPad.

I was hoping that I’d find a Markdown file for each of my posts. But, the generated repo on GitHub only has Javascript files.

The next step would be to publish to DEV from a GitHub repo. When I’m on a PC, I prefer to use a text editor to write the posts. I currently have a GitHub pages blog that is automatically generated from a GitHub repo. It would be nice to setup a workflow such that when I post to that repo it is published on DEV as well.

The Scale Cube

vikrampawar — Sun, 14 Jun 2020 12:21:02 +0000

The Art of Scalability (Addison-Wesley, 2015) talks about Scale Cube. Here is an adaptation of the concept in the context of messaging.

X axis scaling is having more than one message flow to process messages. That is, having more instances of the flow running.

Y axis scaling is having one message flow for each kind of message. Say one flow for one country.

Z axis scaling is splitting the message into smaller parts say instead of having both order and customer in the same message, have a separate order message, and a customer message.

Select any open tab in Sublime, VS Code, and Eclipse with ease

vikrampawar — Fri, 12 Jun 2020 17:43:44 +0000

When working in text editors and IDEs, it's natural to have several tabs open. To work efficiently with the tabs, it is good to be acquainted with the commands we can use to quickly move between the tabs.

I use Eclipse extensively as I do development in Java and IBM ESQL. I have been using Sublime for quite some time, and I've recently started using VS Code. The first thing I did was to opt for Sublime key-bindings in VS Code. So the actual key-bindings of the commands I mention below may be different.

Now coming to the topic of the post, first and basic way to work with tabs is to be able to cycle between the tabs.

In Eclipse, I can cycle between the open tabs using cntrl-F6. In Sublime (and VS Code), I can use ctrl-tab and ctrl-shift-tab.

The next level up would be to get a list of all the open tabs and select the one I want. In Eclipse, I can press ctrl-e to get a list of open tabs and then I can type a few characters to filter the list, and select the tab I want.

Today, I discovered that I can use the same key combination ctrl-e in Sublime and it works exactly as in Eclipse.

So, I suddenly began missing this in Sublime :). I searched and found this helpful Stack Overflow link. I implemented the suggestion and now I can use ctrl-e in Sublime as well and do the same thing.

Only thing is that ctrl-e in Sublime actually does something called slurp_find_string which basically selects the word under cursor as the string to search for in a find command. I won't be able to use it now unless I map it to a new key. I resist using new key combinations. I never really use this command in that much in Sublime. So, I'll leave it for now. I remember that I used to like a similar feature in Vim, where I could press '*' and the cursor moves to next occurrence of the word under cursor.

Sometimes using a new tool teaches us something that makes us look at familiar tools in a new light. So, although I know that all editors more or less do the same thing, I still play around with new ones to learn new things.

Same Repo On Both Bitbucket And Github

vikrampawar — Thu, 11 Jun 2020 18:58:40 +0000

I used bitbucket as my main remote hub for some years now. The main reason was that we use bitbucket at work, so I was more familiar with it. The other reason of course was that I could host my private repositories there. Now Github also allows hosting of private repositories, so I wanted to add Github as another remote to my existing git repositories. Here is what I did.

First I checked what is the remote by using the below command.

# Shows remote
git remote -v show

### output
origin  https://Vikrampawar@bitbucket.org/Vikrampawar/javaprojects.git (fetch)
origin  https://Vikrampawar@bitbucket.org/Vikrampawar/javaprojects.git (push)

Then I looked at the git config in a text editor.

The config is in the file .git/config. It has an entry as below

[remote "origin"]
    url = https://Vikrampawar@bitbucket.org/Vikrampawar/javaprojects.git
    fetch = +refs/heads/*:refs/remotes/origin/*

To set Github as another remote, I ran the below command.

git remote set-url origin --add git@github.com:vikrampawar/javaprojects.git

### output
origin  https://Vikrampawar@bitbucket.org/Vikrampawar/javaprojects.git (fetch)
origin  https://Vikrampawar@bitbucket.org/Vikrampawar/javaprojects.git (push)
origin  git@github.com:vikrampawar/javaprojects.git (push)

This added the remote to the config

[remote "origin"]
    url = https://Vikrampawar@bitbucket.org/Vikrampawar/javaprojects.git
    fetch = +refs/heads/*:refs/remotes/origin/*
    url = git@github.com:vikrampawar/javaprojects.git

I had issues. So, I first created an empty project called 'javaprojects' on Github, and then I also changed the protocol to https instead of git.

git remote -v show
### output
origin  https://Vikrampawar@bitbucket.org/Vikrampawar/javaprojects.git (fetch)
origin  https://Vikrampawar@bitbucket.org/Vikrampawar/javaprojects.git (push)
origin  https://github.com/vikrampawar/javaprojects.git (push)

When I did a push, it worked. I have the repo on Github as well now.

This only works one way now. I can push changes to Github, but I can't pull from it. I'll do that setup later.

Java Streams operate on the whole set

vikrampawar — Sun, 31 May 2020 17:10:14 +0000

Streams can help us do a lot of processing that we would traditionally do using Collections. However, there are some crucial differences between the two.

Collections operate on memory. By the time we use collections, all the elements of the collection are already in memory and are accessible. Streams operate on a set of elements all of which are not yet in memory. Streams can be infinite as well.

Collection operations are imperative. They work on one item at a time. Stream operations work on the whole set. It's a bit amusing that, although the whole collection is in memory, collection operations work on one item at a time, whereas, the Stream operations work on the whole set, although not all of the items are in memory.

Consider the below java code. It produces the Pythogorean triplets in a given range of integers. These are numbers that satisfy the equation a*a + b*b = c*c.

IntStream.rangeClosed(1, 10)
    .boxed() 
    .flatMap(a -> IntStream.rangeClosed(a, 15) 
            .mapToObj( b -> new double[]{a, b, Math.sqrt(a*a + b*b)}))  
    .filter(t -> t[2] % 1 == 0)
    .forEach(t ->  System.out.println(t[0] + ", " + t[1] + ", " + t[2]));

First, obtain a stream of the range of integers using IntStream.rangeClosed(1, 10).

From this, obtain a stream of Integers using boxed().

From this, obtain all possible triplets using flatMap(). (See a demo of the flatMap

Then, filter only those that satisfy the equation.

Note that after each operation, we end up with a stream. We don't operate on individual elements, but the whole set. The below program shows the output after each step.

Also, in the complete program below, note the suble difference in the two ways the final filter can be applied. In the first version, the filter is applied after the flatMap operation and in the second version, the filter is applied within the flatMap operation. The final result is the same in both cases.

The complete program.

import java.util.stream.IntStream;

public class PythogoreanTriplets {

    public static void main(String[] args) {

        System.out.println("\n\nStep 1 - Get stream of Integers 1 to 10 \n------");     
        IntStream.rangeClosed(1, 10)
                .boxed()
                .forEach(e -> System.out.print(e + " "));

        System.out.println("\n\nStep 2 - Get possible triplets \n------");      
        IntStream.rangeClosed(1, 10)
                .boxed()
                .flatMap(a -> IntStream.rangeClosed(a, 10)
                        .mapToObj( b -> new double[]{a, b, Math.sqrt(a*a + b*b)}))                      
                        .forEach(t ->  System.out.println(t[0] + ", " + t[1] + ", " + t[2]))
                ;

        System.out.println("\n\nStep 3a - Filter the right ones, one way \n------");
        IntStream.rangeClosed(1, 10)
                .boxed() 
                .flatMap(a -> IntStream.rangeClosed(a, 15) 
                        .mapToObj( b -> new double[]{a, b, Math.sqrt(a*a + b*b)}))  
                .filter(t -> t[2] % 1 == 0)
                .forEach(t ->  System.out.println(t[0] + ", " + t[1] + ", " + t[2]));

        System.out.println("\n\nStep 3b - Filter the right ones, another way \n------");
        IntStream.rangeClosed(1, 10)
                .boxed() 
                .flatMap(a -> IntStream.rangeClosed(a, 15) 
                        .mapToObj( b -> new double[]{a, b, Math.sqrt(a*a + b*b)})  
                        .filter(t -> t[2] % 1 == 0))
                .forEach(t ->  System.out.println(t[0] + ", " + t[1] + ", " + t[2]));

    }

}

The example is based on an example from the book Modern Java Development

The output will be

Step 1 - Get stream of Integers 1 to 10 
------
1 2 3 4 5 6 7 8 9 10 

Step 2 - Get possible triplets 
------
1.0, 1.0, 1.4142135623730951
1.0, 2.0, 2.23606797749979
1.0, 3.0, 3.1622776601683795
1.0, 4.0, 4.123105625617661
1.0, 5.0, 5.0990195135927845
1.0, 6.0, 6.082762530298219
1.0, 7.0, 7.0710678118654755
1.0, 8.0, 8.06225774829855
1.0, 9.0, 9.055385138137417
1.0, 10.0, 10.04987562112089
2.0, 2.0, 2.8284271247461903
2.0, 3.0, 3.605551275463989
2.0, 4.0, 4.47213595499958
2.0, 5.0, 5.385164807134504
2.0, 6.0, 6.324555320336759
2.0, 7.0, 7.280109889280518
2.0, 8.0, 8.246211251235321
2.0, 9.0, 9.219544457292887
2.0, 10.0, 10.198039027185569
3.0, 3.0, 4.242640687119285
3.0, 4.0, 5.0
3.0, 5.0, 5.830951894845301
3.0, 6.0, 6.708203932499369
3.0, 7.0, 7.615773105863909
3.0, 8.0, 8.54400374531753
3.0, 9.0, 9.486832980505138
3.0, 10.0, 10.44030650891055
4.0, 4.0, 5.656854249492381
4.0, 5.0, 6.4031242374328485
4.0, 6.0, 7.211102550927978
4.0, 7.0, 8.06225774829855
4.0, 8.0, 8.94427190999916
4.0, 9.0, 9.848857801796104
4.0, 10.0, 10.770329614269007
5.0, 5.0, 7.0710678118654755
5.0, 6.0, 7.810249675906654
5.0, 7.0, 8.602325267042627
5.0, 8.0, 9.433981132056603
5.0, 9.0, 10.295630140987
5.0, 10.0, 11.180339887498949
6.0, 6.0, 8.48528137423857
6.0, 7.0, 9.219544457292887
6.0, 8.0, 10.0
6.0, 9.0, 10.816653826391969
6.0, 10.0, 11.661903789690601
7.0, 7.0, 9.899494936611665
7.0, 8.0, 10.63014581273465
7.0, 9.0, 11.40175425099138
7.0, 10.0, 12.206555615733702
8.0, 8.0, 11.313708498984761
8.0, 9.0, 12.041594578792296
8.0, 10.0, 12.806248474865697
9.0, 9.0, 12.727922061357855
9.0, 10.0, 13.45362404707371
10.0, 10.0, 14.142135623730951


Step 3a - Filter the right ones, one way 
------
3.0, 4.0, 5.0
5.0, 12.0, 13.0
6.0, 8.0, 10.0
8.0, 15.0, 17.0
9.0, 12.0, 15.0


Step 3b - Filter the right ones, another way 
------
3.0, 4.0, 5.0
5.0, 12.0, 13.0
6.0, 8.0, 10.0
8.0, 15.0, 17.0
9.0, 12.0, 15.0

The blogpost

Java Streams flatMap Demo

vikrampawar — Sun, 31 May 2020 17:06:41 +0000

The below example shows how we can use flatMap() to get the unique combination of two integers for all integers up to n. For n=3, this would be
(1, 1) (1, 2) (1, 3) (2, 2) (2, 3) (3, 3).

To obtain a stream of 3 integers (1, 2, 3) use IntStream.rangeClosed(1, 3)

Map works with a stream of types, so convert this to a stream of 3 Integers by using .boxed().

Now starting from 1, we want to make a combination of that number with each integer following it.

So for each i we can obtain another stream by IntStream.rangeClosed(i, n).

If we use map(), as below, we'll end up with a stream of streams.

map(a -> IntStream.rangeClosed(a, 3)
    .mapToObj( b -> new double[]{a, b}))

This would be a stream of 3 streams. The first stream will have [1, 1] [1, 2] [1, 3], the second will have [2, 2] and [2, 3]. The third will have [3, 3].

If instead, we use flatMap() as below, we'll end up with one stream.

flatMap(a -> IntStream.rangeClosed(a, 3)
    .mapToObj( b -> new double[]{a, b}))

This would be the stream
[1, 1] [1, 2] [1, 3] [2, 2] [2, 3] [3, 3].

The complete program.


import java.util.stream.IntStream;
public class FlatMapDemo {
    public static void main(String[] args) {

        System.out.println("\n\nStep 1 one primitive integer stream \n------");     
        IntStream.rangeClosed(1, 3)  // one stream
            .forEach(t -> System.out.print(t + " - primitive " +  ", "));

        System.out.println("\n\nStep 2 boxed to Integer stream \n------");      
        IntStream.rangeClosed(1, 3).boxed()  // one stream
            .forEach(t -> System.out.print(t + " - " + t.getClass().getTypeName() + ", "));

        System.out.println("\n\nStep 3 Print stream Regular map \n------");     
        IntStream.rangeClosed(1, 3)
            .boxed()
            .map(a -> IntStream.rangeClosed(a, 3)                  // regular map, stream of streams
                .mapToObj( b -> new int[]{a, b}))
            .forEach(t ->  System.out.println(t  +  " - contains " + t.count()));

        System.out.println("\n\nStep 4 Print stream Flat map \n------");        
        IntStream.rangeClosed(1, 3)
            .boxed()
            .flatMap(a -> IntStream.rangeClosed(a, 3)               // flat map, one stream
                .mapToObj( b -> new int[]{a, b}))
            .forEach(t ->  System.out.println(t + " - " + t.getClass().getTypeName() + " Contents: " + t[0] + ", " + t[1]));
    }
}

The output will be

Step 1 one primitive integer stream 
------
1 - primitive , 2 - primitive , 3 - primitive , 

Step 2 boxed to Integer stream 
------
1 - java.lang.Integer, 2 - java.lang.Integer, 3 - java.lang.Integer, 

Step 3 Print stream Regular map 
------
java.util.stream.IntPipeline$1@6aceb1a5 - contains 3
java.util.stream.IntPipeline$1@4c75cab9 - contains 2
java.util.stream.IntPipeline$1@1ef7fe8e - contains 1

Step 4 Print stream Flat map 
------
[I@6979e8cb - int[] Contents: 1, 1
[I@763d9750 - int[] Contents: 1, 2
[I@5c0369c4 - int[] Contents: 1, 3
[I@2be94b0f - int[] Contents: 2, 2
[I@d70c109 - int[] Contents: 2, 3
[I@17ed40e0 - int[] Contents: 3, 3

Link to blogpost