Tutorial

DynamoDB Core Components

Amazon DynamoDB: Core Components

  DynamoDB is a part of Amazon Web Services. It is a NoSQL database, which supports key-value and document data structures. In this blog, we will be discussing Core components of DynamoDb. Features of DynamoDb: It is a fully managed NoSQL database. It can store & retrieve any amount of data, and can serve any amount of traffic. To maintain fast performance, it distributes data Continue Reading

monads

Back2Basics: Exception Handling – #4

In the previous series of blogs, we have seen how we can do error handling in Scala. In this blog, we will explore yet another way of handling exceptions using the functional style of programming. Scalactic is a library which provides an “Either with attitude” named Or, designed for functional error handling. Or gives you more convenient chaining of map and flatMap calls (and for Continue Reading

monads

Back2Basics: Exception Handling – #3

In our previous blog Exception Handling – #2, we talked about how we can handle exception using Either. In this blog, we will explore further about Either, how we can elegantly handle exceptions using Either while working with Collections. We use collections when we want to perform some operations on elements. But what if something goes wrong while performing the transformation, do you have any Continue Reading

Akka http with json4s

Akka Http uses the spray-json library for JSON support. But a few days back while working on a project which was using the json4s library for marshalling/unmarshalling, I got stuck during parsing of JSON request and extracting that parsed values into my target Scala data model.

Concepts of CQRS

In the previous blog, we have learnt what Event Sourcing is. Moving forward, we will dive into the concepts of CQRS, understanding its meaning, why is it required and its advantages. CQRS Pattern CQRS stands for Command Query Responsibility Segregation. As the name suggests, we split the application in two parts: Command-Side and Query-Side. Now one will ask what this command and query means? Okay, Continue Reading

Introduction to Event Sourcing

Have you ever come across the terms Event Sourcing and CQRS? This blog is a good start to gain basic knowledge about the two. Here, we will learn what is Event Sourcing? And what are the benefits of having an event sourced application? CQRS will be covered in the next blog. What is Event Sourcing? Event sourcing is the practice of capturing all changes as Continue Reading

Fusion of Observables with Observer

RxJs is an incredible tool for reactive programming, and today we’re going to understand briefly about what Observables and observers are. OBSERVABLES Observables are wrapping around of some data source like a stream of values of any type which are typically used for asynchronous data. It is used for transfer of messages between publisher and subscriber and that message could be anything like literals, messages, Continue Reading

Back2Basics: The Magic of Implicit – #2

In our previous blog, The Magic of Implicit, we have talked about how implicit values are being used. In this blog, we will explore Type Conversion with implicit and implicit classes. Let’s start with a simple example, scala> val i: Int = 2.3 <console>:11: error: type mismatch; found : Double(2.3) required: Int val i: Int = 2.3 Here we were trying to assign a double type value Continue Reading

Do you know Akka-HTTP Cache?

Today we are to going to talk about a very important aspect of reactive web applications development. It’s not from the alien world, we always talk about it but we rarely want to deal with it. It’s Cache. In today’s mammoth scalable architecture, we are mostly surrounded by big design issues and somewhere here and there we neglect benefits of using a very useful concept Continue Reading

Back2Basics: Demystifying Variance

In this blog, we will explore types of variances in Scala. In-variance Co-variance Contra-variance First, let’s talk about Types in Scala. scala> import java.util.ArrayList scala> var ref1: Any = “Hi” ref1: Any = Hi scala> var ref2: String = “Hi” ref2: String = Hi scala> ref1 = ref2 ref1: Any = Hi In the above example, ref1 is of type Any and ref2 is of Continue Reading

Back2Basics: Limit which classes a Trait can be mixed into!

A Scala trait is just like a Java interface. A trait can be extended by different classes, just the way we do with Java interfaces and also a class can inherit multiple traits, called mixins. To know more about basics of the trait, refer to this blog. But what if we want to restrict mixing of traits to a limited number of classes? Do we have Continue Reading

Back2Basics: The Magic of Implicits

Implicit System is one of Scala’s language greatest feature with the help of which we can write concise code. The implicit system in Scala allows the compiler to adjust code using a well-defined lookup mechanism. In this post, we will try to understand how Scala’s implicit work magically. Scala provides an implicit keyword that can be used in two ways: method or variable definitions, and method parameter lists. Continue Reading

Amazon ES – Secure your cluster from anonymous users! #2

In the previous blog, we have learned how to create a domain on Amazon ES and also how to create an index using Curl on the cluster. Now, let’s just look how we can control access to Amazon ES Domain. One of the key benefits of using Amazon ES is that you can utilize AWS Identity and Access Management (IAM) to control access to your Continue Reading

%d bloggers like this: