DEV Community: Meenakshi

COVID-19 Vaccines in India: How to Build an API-based Vaccine Locator with Postman

Meenakshi — Tue, 11 May 2021 19:15:57 +0000

The Co-Win portal is a critical website for India at this time, allowing Indians to register and schedule vaccinations against COVID-19 (please note that the portal may lead to a 403 Forbidden error if you’re not in India), and it has published the Co-Win APIs. Since the population of India is so large and the situation is extremely tense right now, the available vaccination slots get booked in seconds. During the initial days of the vaccine, Postman Chief Software Architect Shamasis Bhattacharya and Postman Software Engineer Intern Himanshu Sharma used the Postman Collection Runner to receive alerts on the availability of vaccines in their respective areas—and they managed to get vaccinated. Though the portal’s traffic has increased considerably since, and getting a vaccine appointment has become more difficult, we still think that automating updates when a resource is available is especially useful during the pandemic. We hope you can apply this approach to other helpful APIs in addition to the Co-Win API used in this tutorial.

Getting started

We wanted to share the Postman Collections, monitors, and APIs used by our Postmanauts to configure alerts and visualize available vaccines, so we created a public workspace for anyone to access. The new COVID-19 Vaccine Locator India public workspace contains collections that allow you to receive updates based on configurable parameters, including age limit, vaccine type, and the number of vaccinations required. You can fork the collections you find useful to receive alerts on Slack and Telegram.

COVID-19 Vaccine Locator India public workspace Overview page

Configure alerts

The Co-Win 2-week Alert collection and the Co-Win n-day Alert collections are useful for receiving alerts once the vaccines are available. The respective collection documentation explains the difference between the two and their filtering criteria:

Co-Win 2-week Alert sends alerts for vaccines available in the next two weeks
Co-Win n-day Alert sends alerts for vaccines available in the next n days

In order to configure alerts, fork the collection and the Co-Win environment. Once forked, you need to run the collection at regular intervals in order to receive regular alerts. This can be done in three ways:

1. Configure alerts via the Postman Collection Runner

The Postman Collection Runner lets you run a collection by specifying a delay in milliseconds between collection runs. This is recommended because you can set the smallest delay between runs which would enable you to get notified quicker if vaccination is available. Since Postman the Co-Win API may return a 403 Forbidden for a client other than India, be sure to not select the Cloud Agent, instead choose the Desktop agent if you are using the web version. Please Note: Requests fired from the desktop will only work for clients in India.

Running a collection via the Collection Runner

The only downside to this approach is that you will have to keep your machine running the entire time.

2. Configure alerts via Postman CLI: Newman

Postman monitors run requests on Postman servers, where the Co-Win API may return a 403 Forbidden since these APIs only work for clients in India. Even though Postman monitors allow us to configure regions, the closest region we can get is the Asia Pacific but not specifically India. In that case, we can still reuse all the code in the collections and the environment by running it locally/remotely (on a server in India) using Newman. Since the collections run on a remote server we need not keep the machine running all day as opposed to the previous approach using the Collection Runner.

In order to use Newman, you need to first install it locally or on any other environment (you can try AWS ECS scheduled task, Google’s App Engine Cron Service). Once installed, to run the collection referencing the environment, either export the collection or find the collection URL. Using the URL directly is far more convenient because then you can modify the collection in Postman and without exporting expect to see that change reflected whenever Newman runs.

To find the URL for a collection/environment in your personal workspace, you will need the Postman API Key. The API token can be used to fetch a collection or environment using the Postman API by using these formats:

newman run "https://api.getpostman.com/collections/$collection_uuid?apikey=$apikey" --environment "https://api.getpostman.com/environments/$environment_uuid?apikey=$apikey"

Pro Tip: Set the environment variable values to the initial value you prefer. Newman only picks up the initial value defined in the environment, since the current value doesn’t get synced to the Postman server.

3. Configure alerts via monitors

Click on the “Monitors” tab on the left, and create the monitor. Select Co-Win as the environment and the collection to monitor. Configure how often you want the monitor to run. For every subsequent run, the monitor will find vaccines matching above mentioned criteria.

Pro Tip: Set the environment variable values to the initial value you prefer. Monitors only pick up the initial value defined in the environment, since the current value doesn’t get synced to the Postman server.

Creating a Postman monitor

Receive Slack and Telegram alerts

In order to receive alerts on Slack or Telegram, you need to provide some details (i.e., an auth token/key) or configure a webhook, bot, etc.

How to set up a Slack webhook

To send an alert on a Slack channel, we need to configure an incoming webhook for Slack. Once the incoming webhook is set up, you can copy the webhook URL and set the environment variable slack_hook to that value.

How to set up a Telegram Bot

To send an alert to Telegram, you can create a Telegram bot by sending a text to BotFather. Read How to create a Telegram bot? to learn how to receive a bot API token. Set the environment variable telegram_token to the token received. Next, we need a chat ID to send the text message to the bot. To obtain the chat_id, type a message in the custom bot chat and send. Now, hit the following API to get the chat_id in the response:

https://api.telegram.org/bot{{telegram_token}}/getUpdates

Set the chat_id received to the environment variable telegram_chat_id_._

How to test existing collection workflows

There is a fair bit of logic involved in the tests and the pre-request script for each of the requests. You’ll need to do some filtering and merging based on the criteria defined in the environment. The goal of these collections is for anyone to not only receive alerts but also be able to customize certain conditions based on their requirements. For that, the code needs to be maintainable. As a user, you don’t want to break existing functionality while modifying or adding certain filters. Since hitting the actual Co-Win API for testing isn’t feasible, especially because the server could be down sometimes due to traffic or geo-locks, we created a mock server by importing the OpenAPI definition for Co-Win API. The Co-Win API collection is the source of truth for the mock server. Any example added to a request should reflect in the mock server behavior.

In order to test the collection, you need to do the following:

Switch the base_url to point to the mock_url in the environment
The pre-request script of both collections-Co-Win 2-week Alert as well as Co-Win n-day Alert-have request IDs listed

Pre-request script of collections to target the mock server

How does the pre-request script test for different scenarios?

The pre-request script adds a universally unique identifier (UUID) to the x-mock-response-id header. This will make sure that the mock server always returns the example response matching the path and the UUID requested in the header. Since we have the success example UUID uncommented, the mock server will return only the success response each time, and we can run the collection and test if all the logic in the scripts performs as expected for a success scenario.

What should you use to run the collection while testing?

Postman’s Collection Runner, unlike a monitor, will point to the current value in the environment and can work on the Postman desktop agent which means you may not receive a 403 Forbidden because of the geo-lock while hitting the Co-Win API and you can use the same runner against the mock server by modifying the base_url current value.

How to contribute to this public workspace

There are multiple ways you can contribute to the important work of the COVID-19 Vaccine Locator India public workspace or any other public workspace:

Add collections alerting for different use cases
Add alerts for other products/platforms (Whatsapp, Messenger, etc.)
Separate out the testing via mock server logic from pre-request to a different collection to enable ease of use
Add more visualizations
Add comments wherever helpful

You can fork an existing collection and make changes to experiment with different options. Once complete, raise a pull request to the collection in the workspace. To contribute by adding a new collection to the COVID-19 Vaccine Locator India workspace, fork the CONTRIBUTIONS collection and raise a pull request against it.

It is a critical time to band together and apply all of our technical proficiency in order to discover new ways to fight the pandemic. We hope this approach inspires you to build automated solutions to ease the process when constantly waiting for resources-whether now or for future circumstances.

Originally published at https://blog.postman.com on May 11, 2021.

Problem: Spreadsheets. Solution: Specifications

Meenakshi — Mon, 10 May 2021 13:47:34 +0000

This is a story inspired by true events, about a team and the everyday struggles they faced while building an API defined by spreadsheets and documents. What can come to the rescue in such a scenario? API specifications.

In analysis

A business analyst and a developer may have different objectives and perspectives

Here’s an example of a conversation that you may have been part of sometime in your life as a developer.

Business Analyst: Our next user story involves creating an API (let’s call it “Customer API”).
Developer A: How novel! That’s what I did yesterday and the day before and the day before that.
Business Analyst: Great, should I let the clients know that it wouldn’t take as long to build it?
Developer A: Hold on. We haven’t even heard the requirements for Customer API.
Business Analyst: It’s just a couple of hundred fields that Customer API needs to send to another downstream API to perform the transaction.
Developer A: And how will we know the values for these fields that Customer API needs to send?
Business Analyst: I’ll take care of it. I have already spoken to the lead developer from the downstream API team, and he’s sent me a spreadsheet. It has all the fields and the values that need to be part of the request body. He’s also sent me a document with information on the headers and auth details required to call the downstream API.
Developer A: Is this downstream API available in a testing environment? A playground, maybe?
Business Analyst: They’re still working on building the downstream API, so they don’t have a working version yet.

In development

Developer A gets to work. She pairs with Developer B, another application developer on her team, to finish the Customer API story. Business Analyst sends them an email with a spreadsheet containing the fields and a document that includes the API currently in development by the downstream API team. It seems like Developer A and Developer B have all the information required to start building the Customer API, so they come up with the following list of tasks:

Create the Customer Request model that has all the fields from the spreadsheet.
Fill the model with default values.
Build the Customer API that will use this model as part of the request body.

Seems straightforward. That’s what Developer A and Developer B felt too. Let's see what happened.

In the soup

When Developer A and Developer B scanned the spreadsheet, it didn’t have a hundred fields (as Business Analyst said) but 300 fields. Did that slow them down? Yes, it did.

Let’s look at some of the challenges they faced and what they did.

How did Developer A and Developer B convert fields from the spreadsheet to data members of a class?

Developer B started by showing off some editing skills in his favorite integrated development environment (IDE). To be fair, he recently acquired these skills from another developer last week. Now was his chance to shine. He simply showed Developer A how to paste the fields from the spreadsheet to the class file and some shortcuts on the IDE to clean the copy/paste bit and replace it with Kotlin (the language they used) syntax for a class.

How did they assign the values to the fields?

Not all fields had default values, so assigning defaults to specific fields became a manual process for them, which of course took a while and some patience to complete.

Why are we saying they were in the soup?

Because here’s what happened over the course of the project. Integration failed due to:

Incorrectly spelled fields
Case sensitive fields
Mismatched data types: Some fields were represented as Boolean when they were actually Strings
Error parsing issues, since the document misrepresented it
Missing responses (200 OK even) for some paths

A developer can feel in the soup due to integration failure

In retrospect

I relate to the character of Developer A in this scenario so much, because these are issues that my team has faced. For us, the problems kept popping up frequently, and the integration took a couple of months. I always wondered if there was a better way to communicate—or a process to spend less time on—the issues we faced. Fast-forward to today, and I am glad to report that I’m now fairly acquainted with API specifications.

What are API specifications, and why use them?

A spreadsheet (or a doc) may be tempting to use because it doesn’t come with a lot of rules, but a specification has the same benefit plus more. Here are a few reasons why I’ve become an advocate of specifications (like the OpenAPI Specification):

Conformance to a format

Specifications have a format, and the format could be JSON/YAML, which is much closer to an API than plain text. Examples of APIs and their formats:

Twilio Messaging API: Defined in JSON format
Postman API: Defined in YAML format

Schema objects

Schema objects can be defined, and that would resolve the error response parsing issues we faced earlier. Below is an example of a defined schema object.

In the Dolby Media Analyze OpenAPI, RequestError is a schema object defined as follows:

RequestError:     
     type: object     
     properties:       
       type:         
         description: A URL that uniquely identifies the problem type.         
         type: string         
         example: "/problem/validation-error"       
     title:         
       description: A human readable description of the error.         
       type: string         
       example: "Your request parameters didn't validate"       
     status:         
       description: The HTTP response code.         
       type: number         
       example: 400       
     instance:         
       description: The URL of the call for which the error occurred.         
       type: string         
       example: "/media/analyze"       
     detail:         
       description: An optional field with more information depending on the type.         
       type: string         
       example: "job_id is required"

Schema validations

Validations on the specification ensure that at least one successful response is defined for a path. In addition, there are a lot of other validations on the schema.

Discourse API (Validation Errors Example) demonstrating validation errors

The above screenshot displays validation errors found in the schema. Dive right into the Discourse API (Validation Errors Example) to learn more.

Tooling

Specifications are supported by extensive tooling—like code generators, mock servers, documentation, etc. Leverage the tooling available in Postman by following the detailed walkthrough here.

Helpful API blueprints

API specifications are a blueprint for APIs, providing a huge help by describing the structure of the API. Read Postman Chief Evangelist Kin Lane’s blog post to get a high-level view of API specifications currently available.

Spreadsheets served us well in the information age, but as enterprise organizations wrestle with their digital transformation, they are realizing they need a much more precise set of human- and machine-readable tools that can track the exponentially increasing data being produced each day. Specifications now help teams keep up with the perpetual pace of change and remain competitive in today’s ever-evolving and shifting digital landscape.
— Postman Chief Evangelist Kin Lane

To get started, you can define the API schema in Postman using the API Builder. Share your experiences with and without specifications, and then give us your feedback by leaving a comment below.

Postman Game on: How I Got 346 Collection Forks in One Day

Meenakshi — Fri, 09 Apr 2021 15:55:31 +0000

The Postman Games challenge is a new public workspace that contains a series of requests that you send to receive trivia questions—all as a fun way to test your Postman IQ. We published the workspace at the Postman Galaxy global conference this February, and within just one day, the GET Your Postman Game On! collection received more than 300 forks and two pull requests. The game became a popular topic for discussion among event attendees and proved to be a fun way to break the ice at a virtual conference.

Our success with this game can easily be repeated and applied to any developer community, conference, or meetup. So I encourage you to play it yourself and then have a go at recreating the challenge in Postman by following these tips:

1. Make it visually appealing

The Postman Visualizer can come in handy to visualize API responses. We used it to render the crossword and word search games in Postman.

2. Collaborate for feedback

Once you have the collection all set, I recommend sharing the workspace with a private audience for testing. I initially invited just a few Postmanauts to try the quiz by forking the collection. Early collaborative testing helped collect feedback on the questions, possible answers, and the overall experience. On a personal note, it was a great opportunity to collaborate with so many Postmanauts and build something together.

3. Share your collection in a public workspace

Right before your event (after you’ve incorporated all the feedback to optimize your collection), switch your workspace visibility from Team to Public. The public workspace enables anyone with a Postman account to fork the collection. You can track how popular your collection is by watching the number of forks it has. Be sure to spread the word and share the link to see an upward trend of forks.

Pro tip: If the challenge leads to a prize, you’re much more likely to see an increase in the forks.

4. Don’t worry about perfecting it

There were a few issues with the Postman game challenge on the day of the event. While that had me nervous at first, the good part was that it led to a wider scope for contribution. During the conference, a few attendees even raised pull requests with certain fixes (e.g., correcting misspelled words and improving usability) and we merged them to the source. At the end of the day, it’s more about building a community than coming up with a perfect solution.

Let the games begin

Help us improve the challenge by contributing to the Postman Games public workspace. Also, check out the postman-quiz Github repository that includes the source code and all the help you’ll need to recreate the quiz with a different topic. Above all, don’t forget to have fun in the process.

Originally published on https://blog.postman.com/postman-games-public-workspace/

Guidelines for Java code review

Meenakshi — Thu, 01 Apr 2021 07:30:00 +0000

Tips for Java developers to get a jumpstart on reviewing code.

Having another pair of eyes scan your code is always useful and helps you spot mistakes before you break production. You need not be an expert to review someone’s code. Some experience with the programming language and a review checklist should help you get started. We’ve put together a list of things you should keep in mind when you’re reviewing Java code. Read on!

1. Follow Java code conventions

Following language conventions helps quickly skim through the code and make sense of it, thereby improving readability. For instance, all package names in Java are written in lowercase, constants in all caps, variable names in CamelCase, etc. Find the complete list of conventions here.

Some teams develop their own conventions, so be flexible in such cases!

2. Replace imperative code with lambdas and streams

If you’re using Java 8+, replacing loops and extremely verbose methods with streams and lambdas makes the code look cleaner. Lambdasand streamsallow you to write functional code in Java. The following snippet filters odd numbers in the traditional imperative way:

List **<** Integer **>** oddNumbers **=**  **new** ArrayList**<>();**
 **for** **(**Integer number **:** Arrays **.** asList**(**1 **,** 2 **,** 3 **,** 4 **,** 5 **,** 6**))**  **{**
    **if** **(**number **%** 2 **!=** 0**)**  **{**
      oddNumbers **.** add**(**number**);**
  **}**
 **}**

This is the functional way of filtering odd numbers:

List **<** Integer **>** oddNumbers **=** Stream **.** of**(**1 **,** 2 **,** 3 **,** 4 **,** 5 **,** 6**)**
  **.** filter**(**number **->** number **%** 2 **!=** 0**)**
  **.** collect**(**Collectors **.** toList**());**

3. Beware of the NullPointerException

When writing new methods, try to avoid returning nulls if possible. It could lead to null pointer exceptions. In the snippet below, the highest method returns a null if the list has no integers.

**class**  **Items**  **{**
    **private**  **final** List **<** Integer **>** items **;**
    **public** **Items(**List **<** Integer **>** items**)**  **{**
            **this.** items **=** items **;**
    **}**
    **public** Integer **highest()**  **{**
      **if** **(**items **.** isEmpty**())**  **return**  **null;**
      Integer highest **=**  **null;**
      **for** **(**Integer item **:** items**)**  **{**
          **if** **(**items **.** indexOf**(**item**)**  **==** 0**)** highest **=** item **;**
          **else** highest **=** highest **>** item **?** highest **:** item **;**
      **}**
      **return** highest **;**
    **}**
 **}**

Before directly calling a method on an object I recommend checking for nullsas shown below.

Items items **=**  **new** Items**(**Collections **.** emptyList**());**
Integer item **=** items **.** highest**();**
 **boolean** isEven **=** item **%** 2 **==** 0 **;** _// throws NullPointerException ❌_  
**boolean** isEven **=** item **!=**  **null**  **&&** item **%** 2 **==** 0 _// ✅_

It can be pretty cumbersome to have null checks everywhere in your code though. If you are using Java 8+, consider using the Optional class to represent values that may not have valid states. It allows you to easily define alternate behavior and is useful for chaining methods.

In the snippet below, we are using Java Stream API to find the highest number with a method that returns an Optional. Note that we are using Stream.reduce, which returns an Optional value.

**public** Optional **<** Integer **>** **highest()**  **{**
    **return** items
            **.** stream**()**
            **.** reduce**((**integer **,** integer2**)**  **->** 
                            integer **>** integer2 **?** integer **:** integer2**);**
 **}**
Items items **=**  **new** Items**(**Collections **.** emptyList**());**
items **.** highest**().**ifPresent**(**integer **->**  **{** _// ✅_  
    **boolean** isEven **=** integer **%** 2 **==** 0 **;**
**});**

Alternatively, you could also use annotations such as @Nullable or @NonNull which will result in warnings if there is a null conflict while building the code. For instance, passing a @Nullable argument to a method that accepts @NonNull parameters.

4. Directly assigning references from client code to a field

References exposed to the client code can be manipulated even if the field is final. Let’s understand this better with an example.

**private**  **final** List **<** Integer **>** items **;**
 **public** **Items(**List **<** Integer **>** items**)**  **{**
        **this.** items **=** items **;**
 **}**

In the above snippet, we directly assign a reference from the client code to a field. The client can easily mutate the contents of the list and manipulate our code as shown below.

List **<** Integer **>** numbers **=**  **new** ArrayList**<>();**
Items items **=**  **new** Items**(**numbers**);**
numbers **.** add**(**1**);** _// This will change how items behaves as well_

Instead, consider cloning the reference or creating a new reference and then assigning it to the field as shown below:

**private**  **final** List **<** Integer **>** items **;**
 **public** **Items(**List **<** Integer **>** items**)**  **{**
    **this.** items **=**  **new** ArrayList**<>(**items**);**
 **}**

The same rule applies while returning references. You need to be cautious so as not to expose an internal mutable state.

5. Handle exceptions with care

While catching exceptions, if you have multiple catch blocks, ensure that the sequence of catch blocks is most specific to least. In the snippet below, the exception will never be caught in the second block since the Exception class is the mother of all exceptions.

**try**  **{**
    stack **.** pop**();**
 **}**  **catch** **(**Exception exception**)**  **{**
    _// handle exception_  
**}**  **catch** **(**StackEmptyException exception**)**  **{**
    _// handle exception_  
**}**

If the situation is recoverable and can be handled by the client (the consumer of your library or code) then it is good to use checked exceptions. e. g. IOException is a checked exception that forces the client to handle the scenario and in case the client chooses to re-throw the exception then it should be a conscious call to disregard the exception.

6. Ponder over the choice of data structures

Java collections provide ArrayList, LinkedList, Vector, Stack, HashSet, HashMap, Hashtable. It’s important to understand the pros and cons of each to use them in the correct context. A few hints to help you make the right choice:

Map: Useful if you have unordered items in the form of key, value pairs and require efficient retrieval, insertion, and deletion operations. HashMap, Hashtable, LinkedHashMap are all implementations of the Map interface.
List: Very commonly used to create an ordered list of items. This list may contain duplicates. ArrayList is an implementation of the List interface. A list can be made thread-safe using Collections.synchronizedList thus removing the need for using Vector. Here’s some more info on why Vector is essentially obsolete.
Set: Similar to list but does not allow duplicates. HashSet implements the Set interface.

7. Think twice before you expose

There are quite a few access modifiers to choose from in Java — public, protected, private. Unless you want to expose a method to the client code, you might want to keep everything private by default. Once you expose an API, there’s no going back.

For instance, you have a class Library that has the following method to check out a book by name:

**public** **checkout(**String bookName**)**  **{**
    Book book **=** searchByTitle**(**availableBooks **,** bookName**);**
  availableBooks **.** remove**(**book**);**
  checkedOutBooks **.** add**(**book**);**
 **}**

**private** **searchByTitle(**List **<** Book **>** availableBooks **,** String bookName**)**  **{**
 **...**
 **}**

If you do not keep the searchByTitle method private by default and it ends up being exposed, other classes could start using it and building logic on top of it that you may have wanted to be part of the Library class. It could break the encapsulation of the Library class or it may be impossible to revert/modify later without breaking someone else’s code. Expose consciously!

8. Code to interfaces

If you have concrete implementations of certain interfaces (e. g. ArrayList or LinkedList) and if you use them directly in your code, then it can lead to high coupling. Sticking with the List interface enables you to switch over the implementation any time in the future without breaking any code.

**public** **Bill(**Printer printer**)**  **{**
    **this.** printer **=** printer **;**
 **}**

**new** Bill**(new** ConsolePrinter**());**
 **new** Bill**(new** HTMLPrinter**());**

In the above snippet, using the Printer interface allows the developer to move to another concrete class HTMLPrinter.

9. Don’t force fit interfaces

Take a look at the following interface:

**interface**  **BookService**  **{**
        List **<** Book **>** **fetchBooks();**
    **void** **saveBooks(**List **<** Book **>** books**);**
    **void** **order(**OrderDetails orderDetails**)**  **throws** BookNotFoundException **,** BookUnavailableException **;**    
**}**

**class**  **BookServiceImpl**  **implements** BookService **{**
 **...**

Is there a benefit of creating such an interface? Is there a scope for this interface being implemented by another class? Is this interface generic enough to be implemented by another class? If the answer to all these questions is no, then I’d definitely recommend avoiding this unnecessary interface that you’ll have to maintain in the future. Martin Fowler explains this really well in his blog.

Well then, what’s a good use case for an interface? Let’s say we have a class Rectangle and a class Circle that has behavior to calculate perimeter. If there is a requirement, to sum up, the perimeter of all shapes — a use case for polymorphism, then having the interface would make more sense, as shown below.

**interface**  **Shape**  **{**
        Double **perimeter();**
 **}**

**class**  **Rectangle**  **implements** Shape **{**
_//data members and constructors_  
    @Override
    **public** Double **perimeter()**  **{**
        **return** 2 **\*** **(this.**length **+**  **this.** breadth**);**
    **}**
 **}**

**class**  **Circle**  **implements** Shape **{**
_//data members and constructors_  
    @Override
    **public** Double **perimeter()**  **{**
        **return** 2 **\*** Math **.** PI **\*** **(this.**radius**);**
    **}**
 **}**

**public**  **double** **totalPerimeter(**List **<** Shape **>** shapes**)**  **{**
    **return** shapes **.** stream**()**
               **.** map**(**Shape **::** perimeter**)**
               **.** reduce**((**a **,** b**)**  **->** Double **.** sum**(**a **,** b**))**
               **.** orElseGet**(()**  **->** **(double)** 0**);**
 **}**

10. Override hashCode when overriding equals

Objects that are equal because of their values are called value objects. e. g. money, time. Such classes must override the equals method to return true if the values are the same. The equalsmethod is usually used by other libraries for comparison and equality checks; hence overriding equals is necessary. Each Java object also has a hash code value that differentiates it from another object.

**class**  **Coin**  **{**
    **private**  **final**  **int** value **;**

    Coin**(int** value**)**  **{**
        **this.** value **=** value **;**
    **}**

    @Override
    **public**  **boolean** **equals(**Object o**)**  **{**
        **if** **(this**  **==** o**)**  **return**  **true;**
        **if** **(**o **==**  **null**  **||** getClass**()**  **!=** o **.** getClass**())**  **return**  **false;**
        Coin coin **=** **(**Coin**)** o **;**
        **return** value **==** coin **.** value **;**
    **}**
 **}**

In the above example, we have overridden only the equals method of Object.

HashMap **<** Coin **,** Integer **>** coinCount **=**  **new** HashMap **<** Coin **,** Integer**>()**  **{{**
  put**(new** Coin**(**1**),** 5**);**
  put**(new** Coin**(**5**),** 2**);**
 **}};**

_//update count for 1 rupee coin_  
coinCount **.** put**(new** Coin**(**1**),** 7**);**

coinCount **.** size**();** _// 3 🤯 why?_

We would expect coinCount to update the number of 1 rupee coins to 7 since we override equals. But HashMap internally checks if the hash code for 2 objects is equal and only then proceeds to test equality via the equals method. Two different objects may or may not have the same hash code but two equal objects must always have the same hash code, as defined by the contract of the hashCode method. So checking for hash code first is an early exit condition. This implies that both equals and hashCode methods must be overridden to express equality.

If you write or review Java code, DeepSource can help you with automating the code reviews and save you a ton of time. Just add a .deepsource.toml file in the root of the repository and DeepSource will pick it up for scanning right away. The scan will find scope for improvements across your code and help you fix them with helpful descriptions.

Originally published on DeepSource Blog.

Tutorial: Intro to React Hooks

Meenakshi — Thu, 01 Apr 2021 07:28:23 +0000

Hangman icon by IconBros

This tutorial assumes knowledge of React state and lifecycle concepts.

Before We Start the Tutorial

We will be building a small game in this tutorial. This is a practical way of getting accustomed to building react functional components using hooks. We will be walking through each section of this tutorial along with the code snippets so that you can follow along as you build your game.

This tutorial is divided into the following sections:

Setup for the Tutorial will equip you with the starter code
Overview will delve into the basics of hooks with some history
Building the Game will use the most common hook in React development
Adding a Time Limit will extend the game to add a time limit
Wrapping Up will discuss extensions and conclude

You can follow along till you build a basic version of the game to get an understanding of the hooks along with some hands-on.

What are We Building?

In this tutorial, we'll build an interactive hangman game using React hooks.

Hangman is a classic game in which the player has to guess a word one letter at a time. You can play to get comfortable with the game
https://www.hangmanwords.com/play

There are several rules that can be applied to the game to add more complexities, but we will be focussing on completing just the first iteration of the game. You are encouraged to experiment and extend this solution for more complex use cases suggested in the extensions section.

Prerequisites

We'll assume you have used React before and are familiar with creating components, state management, and lifecycle methods.
We are also using features from ES6 - arrow functions, const, let statements. You can check Babel REPL to understand what ES6 compiles to.
Note, we are using hooks in this tutorial, since hooks have been introduced in React version 16.8, you would need to have 16.8 as the min. React version for this tutorial.

Setup for the Tutorial

Let's get started.
We want to first create a react app. We can either create it from scratch or use create-react-app to reduce boilerplate code. In this tutorial we'll be using create-react-app.

npx create-react-app react-hangman
cd react-hangman
npm start

The above snippet will create a React app with a simple App component. For this tutorial, we won't be focussing on styling and testing the component, so let's go ahead and delete the App.css and App.test.js files. Now we can simply edit the App.js to include Hangman component. The Hangman.jsx is what we're going to focus on building in this tutorial.

App.js

import React from 'react';
import Hangman from './Hangman';

const App = () => <Hangman />

export default App;

View the full code at this point

Overview

Now that you're all set, let's first get an overview of React hooks.

What are React Hooks?

Prior to 16.8, class components in React were used to manage state and had logic distributed across lifecycle methods. Functional components were used to extract out some common UI. With React hooks, you can now hook into your functional components state and logic that would earlier be spread across lifecycle methods. Related logic can now be in one place, instead of being split. Logic can also be shared across components by building custom hooks.

Building the Game

As part of the first iteration, we want a secret word to be displayed, let's say we mask all the letters with __ and we need all alphabets A-Z to be listed so that the player can select a letter and if that letter is part of the secret word it will reveal itself.

Let's say the secret word is "HANGMAN". Then the following expression should mask the secret word as

_ _ _ _ _ _ _

"HANGMAN".split("").fill("_").join(" ")

Let's start with a basic layout:

Hangman.jsx

import React from 'react';

export default function Hangman() {
    const word = "HANGMAN";
    const alphabets = ["A", "B", "C", "D", "E", "F", "G",
        "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R",
        "S", "T", "U", "V", "W", "X", "Y", "Z"];

    return  <div>
            <p>{word.split("").fill("_").join(" ")}</p>
            {alphabets
            .map((alphabet, index) => 
            <button key={index}>{alphabet}</button>)}
            </div>
}

At this state, if you click on the buttons no actions occur. Our next step would be to click on an alphabet and guess if the letter is a part of the word. If the letter is indeed a part of the word it would show up and if it isn't it would not reveal itself. For this, we need to persist all the letters that are correctly guessed so that they are displayed as part of the secret word. Now we have a use case for persisting data across a component re-render. This calls for the need for the state. Let's have a look at how we can infuse the state using the State hook in React.

The State Hook

We can use the state hook to inject state into functional components in React. This state will be preserved across re-renders of the component. The useState is a hook that we can use. The useState returns a pair having the current value for the state and a function that lets you set the state. In class components, we used to do something similar with this.setState. You can use multiple useState in a component for different values that need to be preserved.

We need to persist correctGuesses for the Hangman component. Let's use the useState hook. We modified the word to display __ for all letters not guessed yet.

import React, {useState} from 'react';

export default function Hangman() {
    const word = "HANGMAN";
    const alphabets = ["A", "B", "C", "D", "E", "F", "G",
        "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R",
        "S", "T", "U", "V", "W", "X", "Y", "Z"];
    const [correctGuesses, setCorrectGuesses] = useState([])    

    const maskedWord = word.split('').map(letter => 
    correctGuesses.includes(letter) ? letter : "_").join(" ");

    return  <div>
            <p>{maskedWord}</p>
            {alphabets
            .map((alphabet, index) => 
            <button key={index} onClick={() => {
                if (word.includes(alphabet)) {
                    setCorrectGuesses([...correctGuesses, alphabet])
                }
            }}>{alphabet}</button>)}
            {!maskedWord.includes("_") && <p>You won!</p>}
            </div>
}

Adding a Time Limit

Now that we have a fair working solution, let's add some rules to this game. We'll have a max time limit of 2 minutes for the word to be guessed, if the word is not guessed within 2 minutes, we'll display "Game Over".

We will need to inject a timeout in this case. The timeout will affect the results of this game. Let's look at the effect hook to understand how we can add the logic of this timeout inside our component.

The Effect Hook

The effect hook is another one of the most commonly used hooks in React. It takes in a function(effect) that runs when any one of its dependant variables is changed. The effect (short for side effect) hook, is used to manage any side effects on the component - manipulating DOM elements, fetching data, subscriptions, etc. In our case, we will use the useEffect to set a timeout. The useEffect runs by default for every component render unless we mention [] as its parameter, in which case it runs only during the first render of the component.

import React, { useEffect, useState } from 'react';

export default function Hangman({duration = 120000}) {
    const word = "Hangman".toUpperCase();
    const alphabets = ["A", "B", "C", "D", "E", "F", "G",
        "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R",
        "S", "T", "U", "V", "W", "X", "Y", "Z"];
    const [correctGuesses, setCorrectGuesses] = useState([])
    const [timeUp, setTimeUp] = useState(false);

    useEffect(() => {
        const timeout = setTimeout(() => {
            setTimeUp(true);
        }, duration);

        return () => clearTimeout(timeout);
    }, [])


    const maskedWord = word.split('').map(letter => correctGuesses.includes(letter) ? letter : "_").join(" ");
    return (
        <div>
            <p>{maskedWord}</p>
            {alphabets.map((alphabet, index) => <button key={index} onClick={() => {
                if (word.includes(alphabet)) {
                    setCorrectGuesses([...correctGuesses, alphabet])
                }
            }}>{alphabet}</button>)}
            {timeUp ? 
            <p>You lost!</p> : 
            !maskedWord.includes("_") &&  <p>You won!</p>}
        </div>
    );
}

Notice how we are preserving the state of timeUp using useState. In the second parameter of useEffect we mention [], so the timeout is set only during the first render of Hangman. In the end, when the component unmounts since the game gets over, we clear up the effect, in return () => clearTimeout(timeout). This can be used to unsubscribe, clear up resources used in the effect.

Wrapping Up

Congratulations! You have a hangman game that :

Let's you play hangman
Has a time cap for you to guess

We hope you've got a hang(pun intended) of the basic hooks.

The tutorial was an attempt to get you started on react hooks. We would further encourage you to explore more hooks, eg. useContext, useHistory, create your own custom hooks. etc. Check out a detailed explanation on hooks here.

There are a lot of rules that can be applied and the game can be further extended. It will be a good exercise for you to try your hand at these functional components using hooks.

Max number of guesses allowed can be 6
Display time left on the timer
Limiting guesses on vowels
Fetch a list of words based on themes

You can find the code sample in this repo. Feel free to write to me at meena24dhanani@gmail.com for any feedback. You can also submit PRs that extend the game.

Kubernetes Tutorial: Your Complete Guide to Deploying an App on AWS with Postman

Meenakshi — Tue, 05 Jan 2021 12:35:38 +0000

Kubernetes is an open source system that is useful for container orchestration. In this tutorial, we are going to use Postman Collections to learn Kubernetes and use its API to deploy an app on a Kubernetes cluster hosted on AWS.

This is a hands-on tutorial. Don't fret if you aren’t familiar with Kubernetes and containerization, because we'll go over each of the following:

Prerequisites
Brief overview on containers
Kubernetes
Creating a Kubernetes cluster
Accessing the Kubernetes API from Postman
Authorizing Postman Collection
Deploy an app
Pod
Deployment
Expose your app
Service
Clean up
What next?

Note: We will be creating the Kubernetes cluster on AWS EKS, but you can also follow the tutorial with a cluster hosted on any other cloud providers or locally using Minikube.

Prerequisites

Familiarity with REST APIs is a prerequisite. In addition you also need to do the following:

Create an AWS account
Install and configure AWS ALI to configure credentials
Install eskctl,a command utility to interact and create the cluster on EKS
Install kubectl, a command-line utility to work with Kubernetes clusters
Clone Github repository containing .yaml files required in upcoming sections
Create your Amazon Cluster IAM role to access the cluster
Setting up Amazon EKS cluster VPC

Here is a helpful Amazon EKS guide that has all of the prerequisites mentioned above and instructions to install them.

Explore this blog post in an interactive format by using our companion template. Just import the Deploy with Amazon EKS and Kubernetes API collection by clicking on Run in Postman to follow this tutorial.

Deploy with Amazon EKS and Kubernetes API Template

A brief overview of containers

Are you familiar with the “But it works on my machine” problem? A lot of times your application doesn’t perform as it does in your local environment. It may be because the production environment has different versions of the libraries, a different operating system, different system dependencies, etc. Containers provide you with a sustainable environment because your application now runs in a box (container) that includes all dependencies required by your app to run and is isolated from other applications running in other containers. They are preferred over virtual machines (VMs) since they use operating system-level virtualization and are lighter than VMs. Docker can be used as the container runtime.

Benefits of containerization

Enter Kubernetes

Each app/service now runs in a container, so there can be a separation of concerns. Services don’t need to be intertwined with each other, and a microservices architecture works best with containerization. We have established why the world is moving towards containers, but who is going to manage these containers and how do you roll out a release? How do you run health checks against your services and get them back up if they are failing? Kubernetes automates all of this for you. You can easily scale up and scale down your services with Kubernetes.

Container orchestration in Kubernetes

You can use Kubernetes anywhere for on-premise deployments or even hybrid clouds. For instance, you can have your cluster on GCE, AWS, Azure, or any cloud provider. For this Kubernetes tutorial, let's create a cluster on AWS.

Read more about the benefits of containerization and container orchestration with Kubernetes here. This is a really enthralling space, especially for folks interested in DevOps.

Creating a Kubernetes cluster

Assuming you have followed the steps in the prerequisites section, you should have eksctl installed. Follow the steps below to create a Kubernetes cluster.

Run the following command to check if eksctl can successfully access the AWS account and list any existing clusters:
```
eksctl get cluster --region us-east-1
```
In case this command fails, you may want to make sure your credentials are set up correctly, as mentioned here.
Next, create a cluster and assign some resources to it. The cluster.yaml is present in the Github project we cloned, as mentioned in the prerequisites. You can customize the configuration for the cluster based on the resources you want to assign to your cluster. You could choose a different region, maybe add more nodes, or also a different instance type. For this tutorial, we do not need as much CPU or memory.

apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig

metadata: 
  name: playground 
  region: us-east-1

nodeGroups: 
  - name: ng-1 
    instanceType: t2.small 
    desiredCapacity: 2

A word of caution: The pricing for larger instances and more number of nodes would be more.

Use the following command to create the cluster:

eksctl create cluster -f cluster.yaml

It may take a while for the cluster to be ready. Once this command succeeds, assuming you have kubectl installed, the configuration for kubectl to access the cluster would be stored at:

~/.kube/config

Try fetching the nodes on the cluster using kubectl. You should be able to see the two nodes if you used the cluster configuration as mentioned above.
```
kubectl get nodes
```
Accessing the Kubernetes API from Postman

Next, we require a service account to communicate with the Kubernetes API. The service account is authorized to perform certain actions, including creating deployments and listing services by attaching it to a cluster role.
Run the following command to create a service account:
```
kubectl create serviceaccount postman
```
Create a role definition for the service account. This role definition specifies all actions that are permitted on the resources mentioned. The role.yaml is present in the GitHub project we cloned, as mentioned in the prerequisites. We will look at what these resources mean and learn how to create them in the next steps.

kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
name: postman-role
rules:
- apiGroups: ["apps", ""] # "" indicates the core API group
  resources: ["pods", "services", "deployments"]
  verbs: ["get", "watch", "list", "create", "update", "delete"]

Run the following command to create the role:

kubectl apply -f role.yaml

Assign the role to the service account by creating a role-binding:
```
kubectl create rolebinding postman:postman-role --clusterrole postman-role --serviceaccount default:postman
```
For every service account created, there is a secret token. Finally, we must extract the following from the token created for the service account:
- - - API server URL
    - Bearer Token
    - CA Certificate
Run the following command to reveal the secret e.g., postman-token-9lxcc:
```
kubectl describe serviceaccount postman
```

Next, we must describe the secret:

kubectl get secret <secret-token> -o json

Execute the command below to reveal the ca.crt certificate and the token, that is inside a data object. We need to decode these to base64 and use them. This can be simplified using jq command-line utility:

# Extract the token from the Secret and decode
TOKEN=$(kubectl get secret <secret-token> -o json | jq -Mr '.data.token' | base64 -d)

# Extract, decode and write the ca.crt to a file
kubectl get secret <secret-token> -o json | jq -Mr '.data["ca.crt"]' | base64 -d > ca.crt

You must get the API server URL from Amazon EKS. If you log in to your Amazon account and see the cluster details for the playground cluster we created, you should find an API server endpoint, which is the URL for the API server that we are going to be hitting via Postman.

API server endpoint of Kubernetes cluster on Amazon EKS

Authorizing the Postman Collection

Assuming the collection is already imported as part of the prerequisites, select the Manage Environments button on the top right, and edit the following:

Environment variables for AWS environment

Paste the API Server Endpoint into the CURRENT VALUE for kube-api-server and the token into auth-token CURRENT VALUE. Click on Update.

Pro Tip: The current value is never shared while sharing the Postman Collection. Also, since these variables have sensitive information, it is best to add them to the environment variables. We could use the same collection and run it on different environments (i.e., GCP, Minikube).

Next, add Authorization to the collection. Adding Authorization at the collection level will ensure all the requests within the collection will be authorized with the same token/credentials.
Click on Edit Collection and under Authorization, select OAuth2.0. We can use the auth-token variable as the Access Token. This token will be passed in the Request Headers for each request.

Adding authorization to a collection

Almost there! The last step to get our collection ready is adding the CA Certificate. Simply click on Settings for Postman, and under Certificates, turn on the CA Certificates toggle to upload the ca.crt file we created. Alternatively, you can disable certificate verification, but that is not recommended.

Adding CA Certificates to access Kubernetes APIs

Deploy an app

We are all set to deploy. First, we need something very important. Not surprisingly, it is an app. Let's take a look at the app.

Enter Dobby. Dobby is an open source project, and it's extremely simple to call different APIs on it and manipulate responses.

We spoke about containerization earlier: a container simply means an app is running in a sandbox. The container is created from an image. If there are any code changes in the app, we recreate the image to reflect the app’s latest changes and rerun the container.

We can find the publicly available image for Dobby here. We must use the image in the request.

The Deploy an App folder in the collection contains requests to create and list Kubernetes objects that will help deploy our app on AWS. Let’s take a quick look at these objects.

Creating a Kubernetes pod

In Kubernetes, pods are a group of containers and also the smallest deployable unit. The pod will define the configuration that is required to create the app container.

Containers in a Kubernetes pod

We must create a pod for Dobby. You should find the configuration as json in the request body. We have created a collection variable called project-name, this variable is going to be used throughout the collection while creating resources, so it made perfect sense to extract it. You can rename the variable if you want.

Click on Body to find the request body as shown in here:

Creating a Pod POST Request

You will find fields for metadata name, the name of the pod, and labels. We'll discuss how labels are useful in the subsequent requests. If you scroll below to the spec you will also find the image that we are using for the containers, and the port the app is supposed to run on.

Press Send. There will be a lot of details in the response body.
Click on Visualize, and if the response is successful, congratulations are in order! Keep going.

Visualization of successful creation of a pod

Send the GET request that lists all pods created. Again, click on the Visualize button:

Visualization to list pods created

Head over to the Clean Up folder, and run the Delete Pod request:

Deleting a pod request

Again, click on Visualize to see the response as a prettier message:

Visualization of successful deletion of a pod

Deployment

In the previous section, we created a pod and deleted it. That means our app is no longer running. In a real-world scenario, though, we would want to have multiple instances of our app running so that the requests could be load-balanced across them. These instances (pods) could be running on different nodes/machines. We want to ensure that at least a minimum amount of instances are running. Deployments can help us manage it all.

Kubernetes deployment

Click on Body to review the request body. The body contains the configuration for the deployment:

Creating a Deployment POST Request

Components of the body:

Replicas: Refer to the number of pods that should be running for a deployment. We are assigning the pods that get created via this deployment a label of -pod.
Labels: Pods are matched to the respective deployments by these labels.

The body also contains a definition for a readiness probe and a liveness probe:

Readiness Probe: Containers are assigned traffic in Kubernetes based on the readiness probe. This can be used when the container is not ready to serve traffic due to other services it depends on, or if it is loading any data/configuration.
Liveness Probe: Containers restart based on the liveness probe. So to check if the Dobby app is up, the /health endpoint will be hit. If it returns a 500 then the containers are restarted.

Press Send to create a deployment and look into the Visualization tab for the next steps:

Visualization of successful deployment creation

Send the GET request that lists all pods created. See results in the Visualization tab:

Visualization listing pods created via deployment

Expose your app

In the previous section, we were able to successfully create a deployment. So how do we access it now? The pods created have IP addresses, but what if we want to access one app from another?

Let's take a look at Kubernetes’ service.

Service

We have two apps—frontend and backend. There are separate pods for the frontend and for the backend. We need to expose the pods of the backend so that the frontend app can access it and use the APIs. We usually configure the IP address or URL for the backend into the frontend. However, if the IP address changes for the backend, those changes would have to be reflected in the frontend app as well. With services, we can avoid these changes.

Kubernetes Service

Review the request body by clicking Body:

Creating a Service POST Request

Components of the body:

Selectors: The selectors help the service map to the pods that have the matching label.
Exposing: Services can be exposed within the cluster for other services (frontend) to access the pods, or outside the cluster for the public to access the service. By default, the service would be of ClusterIP type (this would expose the service inside the cluster). We want to expose this externally, so we chose the LoadBalancer type.

2. Send and view the Visualization tab:

Visualization of successful creation of service

Run the list of service requests to find the IP address of the service. Here’s what you should see under Visualize for the List Services request:

Visualization listing services

The following snippet in the Tests tab will save the external IP for the service to the collection:

const service = pm.response.json().items.filter((item) => item.metadata.name === 
pm.variables.get("project-name")+"-service")[0]pm.collection
Variables.set("service-ip", 
service.status.loadBalancer.ingress[0].hostname)
pm.collectionVariables.set("service-port", service.spec.ports[0].port)

Now we need to access an endpoint on the Dobby app to check if the app is running. Note: It might take a while before the service starts serving requests. Once the service is ready, click on the Say Hello to Dobby request. If you hover over the service-ip and service-port variables, you should see their value that was set by the tests in the previous request:

Dobby health check request

Upon pressing Send, under Visualize you should see the message we have been working so hard for:

Visualization message when Dobby is healthy

Clean up

You will find a Clean Up folder in the collection. It contains all the requests to delete the Kubernetes resources—services, deployments, and pods we created throughout this tutorial.

At the end of the tutorial make sure you delete your cluster, unless you wish to keep it:

eksctl delete cluster -f cluster.yaml

What next?

Hopefully this tutorial helped you get started with Kubernetes. And there’s so much more to explore. Here are some additional things you can try with this Kubernetes collection:

Creating other Kubernetes objects: In this tutorial, we discussed a few Kubernetes objects, including service accounts, pods, deployments, and services. Next, you could explore other kubernetes objects like namespaces and ConfigMaps.
Automate workflows in Postman: You could use the collection runner in Postman to execute common workflows. A workflow in Postman is ordering the requests in a collection to accomplish a task eg. running health checks for all services. Take a look at our blog post about looping through a data file in the postman collection runner and building workflows in Postman.
Automate deployments in CI/CD: In case you want to automate deployments, consider using Newman—command line runner for Postman collections. If you prefer kubectl, you could use that instead.
Experiment with Dobby APIs to learn more: The Dobby app has APIs such as /control/health/sick, which will make the app return an internal server error. You can run these and observe their effect on the liveness and readiness probes to learn more.
Fork collection and raise PR: Additionally, you could also fork the collection and raise a pull request with your changes.

Technical review by Kevin Swiber, lead solutions engineer at Postman.

What do you think about this topic? Tell us in a comment below. You can also give product feedback through our Community forum and GitHub repository.

Real-Time Time Series Chart With Kafka and Socket.io

Meenakshi — Thu, 24 Sep 2020 06:30:42 +0000

Our team at ThoughtWorks, E4R (Engineering for Research) has been working on Epirust- an open-source agent-based modeling solution for epidemiological simulations. In the midst of this pandemic, it is crucial for epidemiologists to make quick and effective decisions that would help control the spread of COVID. Epirust is an attempt to simulate a region, say India with its population as agents and visualize the effect of interventions such as vaccines, the lockdown, and an increase in the number of hospitals on an agent’s daily routine. To know more about the motivations behind this project, head over to the Epirust wiki.

As part of the E4R team, I had the opportunity to work on the visualizations for this project. In this post, I’ll walk you through the architecture of Epirust and the thought process behind using Kafka and web sockets for building the following real-time time series visualization.

Real-time time series chart for a simulation

The data presented in the visualization is received from the backend engine(written in Rust). The engine encapsulates the core logic of generating counts of susceptible, infected, hospitalized, recovered, and deceased agents per hour. These counts are based on a certain input configuration eg. population size, transport percentage, working population percentage, and disease dynamics for COVID.

Let’s break this problem into the following 3 parts:

Streaming data from the backend
API to consume the stream on the frontend
Charting library to visualize this data

Streaming data from the backend

The Rust engine generates a number of agents infected per hour. We wanted to visualize the changing curve for each passing hour of the simulation. Here’s a peek into the JSON received from the engine:

{
  hour: 1,
  infected_std: 1,
  susceptible_std: 100,
  hospitalized_std: 10,
  recovered_std: 2,
  deceased_std: 0,
}

We need a platform to stream these updated counts for each hour in real-time so that the frontend can react by plotting the curve on the graph for every hour. If we think in terms of events, each count generated by the simulation model is an event. Once this event is published, interested parties can subscribe to it and visualize it in their own ways. This is a typical use case of the pub/sub-model.

Kafka is a popular event streaming platform. It’s a distributed platform and hence highly scalable and available. Since the simulations run based on the input configuration, we had certain use cases where we would want the simulation to accept configurations for a city’s climate, population, transport percentage, etc., and scale the model to run on a country level, hence Kafka fit the bill perfectly.

Kafka components

We wrote a Kafka Producer in Rust that would push the count for each hour to a counts_updated topic. The counts_updated topic was further subscribed by the Kafka Consumer on the server. Our idea of having a server component between the Rust engine and the frontend was so that we could persist the simulation data generated for a particular input. eg. We could persist simulation results for 1000 hours having 3000 agents and compare it with 2000 hours having1000 agents.

API to consume data on frontend

We need the frontend to receive the hour messages in real-time. If the frontend were to make an HTTP request to receive the updated counts, it would have to poll for changes making it very difficult for the frontend to know the frequency of polling for messages. Furthermore, this would not be real-time, some delay would have to be factored in. Since we understood that HTTP wouldn’t work in this scenario, we started looking at other means of pushing messages to the client for updates.

Web sockets allow to the establishment of a connection between a web browser and a server. Messages can be relayed in real-time by the server to the client using this connection. For this purpose, we used the library socket.io.

Socket.io has two components:

A server that integrates with NodeJS
A client library that loads messages on the browser side

On consuming the updated counts from the Kafka Consumer, an event epidemicStats with updated counts is emitted from the server on the socket.

socket.emit('epidemicStats', {
  infected_std: 3,
  susceptible_std: 200,
  hospitalized_std: 5,
  recovered_std: 4,
  deceased_std: 0,
});

This event would then be received by the frontend React app listening on the socket for messages. We use the socket.io-client library for this purpose. If the simulation ends, then a message denoting the same is sent.

socket.on('epidemicStats', _function_ (messageRaw) {
    _const_ message = messageRaw;

   _if_ ("simulation_ended" _in_ message) {
        simulationEndedTemp = _true_;
        socket.close();
    }
    _else_ {
        _const_ { hour,
            susceptible, susceptible_std,
            infected, infected_std,
            hospitalized, hospitalized_std,
            recovered, recovered_std,
            deceased, deceased_std } = message;

        _const_ perHourStats = [hour,
            susceptible, susceptible_std,
            infected, infected_std,
            hospitalized, hospitalized_std,
            recovered, recovered_std,
            deceased, deceased_std
        ];

        buff.push(perHourStats);

Charting library to visualize real-time graphs

The time-series graph would be updated frequently, so we needed a library that could accommodate the changes quickly without breaking the UI. After a performance comparison between chart.js, vega-lite, and dygraphs, we realized dygraphs to be the most performant.

Here’s how you create your multiline line chart using dygraphs:

_let_ options = {
    legend: 'always',
    animatedZooms: _true_,
    title: 'Time Series Graph',
    ylabel: 'Number of Agents',
    xlabel: 'Hours',
    showRoller: _true_,
    errorBars: _true_,
    rollPeriod: 24
}
_const_ visualisationDiv = document.getElementById("vis");
_const_ graphInstance = _new_ Dygraph(visualisationDiv, convertToCsv(buff), options);

Dygraphs charts can handle large datasets without getting bogged down. The chart is also very interactive, giving us an easy option to pan and zoom. It accepts a rollPeriod based on which it averages out the curve. Since the data we generated was on an hourly basis, we averaged it out to 24 hours.

Conclusion

We discussed the Rust engine that generates counts of agents that are infected, diseased, hospitalized, etc., and pushes it onto Kafka where a Kafka Consumer on the server reads them and puts them onto the web sockets. This data is received by a React app listening on the socket to plot a line chart that updates in real-time.

The following is an architecture diagram of Epirust. I hope this helps you get the big picture.

Architecture Diagram for Epirust

I’m going to be coming up with part 2 for this series where I’ll talk about the performance comparisons we did among the charting libraries. In the later stages of this project, we also built a grid visualization to track the movements of the agents.

Agent movement across the grid

All the code snippets are taken from the open-source project Epirust. Feel free to explore the project and read more about agent-based modeling. Watch out for the subsequent parts of this series.

Reach out for any feedback and how you think we could have done this better. Happy to hear from you!

Check out the Epirust project-https://github.com/thoughtworks/epirust

DEV Community: Meenakshi

COVID-19 Vaccines in India: How to Build an API-based Vaccine Locator with Postman

Getting started

Configure alerts

1. Configure alerts via the Postman Collection Runner

2. Configure alerts via Postman CLI: Newman

3. Configure alerts via monitors

Receive Slack and Telegram alerts

How to set up a Slack webhook

How to set up a Telegram Bot

How to test existing collection workflows

How does the pre-request script test for different scenarios?

What should you use to run the collection while testing?

How to contribute to this public workspace

Problem: Spreadsheets. Solution: Specifications

In analysis

In development

In the soup

In retrospect

What are API specifications, and why use them?

Conformance to a format

Schema objects

Schema validations

Tooling

Helpful API blueprints

Postman Game on: How I Got 346 Collection Forks in One Day

1. Make it visually appealing

2. Collaborate for feedback

3. Share your collection in a public workspace

4. Don’t worry about perfecting it

Let the games begin

Guidelines for Java code review

1. Follow Java code conventions

2. Replace imperative code with lambdas and streams

3. Beware of the NullPointerException

4. Directly assigning references from client code to a field

5. Handle exceptions with care

6. Ponder over the choice of data structures

7. Think twice before you expose

8. Code to interfaces

9. Don’t force fit interfaces

10. Override hashCode when overriding equals

Tutorial: Intro to React Hooks

Before We Start the Tutorial

What are We Building?

Prerequisites

Setup for the Tutorial

Overview

What are React Hooks?

Building the Game

The State Hook

Adding a Time Limit

The Effect Hook

Wrapping Up

Kubernetes Tutorial: Your Complete Guide to Deploying an App on AWS with Postman

Prerequisites

A brief overview of containers

Enter Kubernetes

Creating a Kubernetes cluster

Accessing the Kubernetes API from Postman

Authorizing the Postman Collection

Deploy an app

Creating a Kubernetes pod

Deployment

Expose your app

Service

Clean up

What next?

Real-Time Time Series Chart With Kafka and Socket.io

Streaming data from the backend

API to consume data on frontend

Charting library to visualize real-time graphs

Conclusion