Insights and perspectives to keep you updated.

MachineX: KNN algorithm using KSAI

Classification is a well-known area of machine learning. the K-Nearest neighbor algorithm is a simple algorithm that keeps all available cases and classifies new cases based on the similarity with existing cases. KNN has been used in pattern recognition as a non-parametric technique. in this algorithm, a case is classified by a majority of votes of its neighbors. if K=1 then the cases are assigned Continue Reading

monads

Back2Basics: Futures in Scala

Hey folks, in this blog we will be discussing and try to gather some knowledge on how multithreading, concurrency can be achieved and asynchronous computations can be done on immutable values by the use of Futures. Why do we need Futures? The concept of Futures was introduced to allow concurrent programming and avoid wastage of resources which will be blocked in case of sequential code. Continue Reading

MachineX: An Introduction to KSAI, a machine learning library

Take a closer look at Linkedin or any media platform for a couple of minutes, you’ll find that the hot topic in the technology section nowadays is Machine Learning and Artificial Intelligence. Why Machine learning and artificial intelligence? Well needless to say it is transforming the world like anything. People are doing good in business by predicting different aspects, doctors are doing good in medical Continue Reading

Structures In Rust

Structures are used to creating a more complex data structure. Basically, we have three types of Structures in Rust: The classic C Structs Tuple structs, which are, basically, named tuples. Unit structs, which are field-less, are useful for generics. In general, If we take an example of length and breadth in case of the area of many of 2D shapes then we calculate the area Continue Reading

Scala : Proxy Design Pattern

Hi Everyone! In our previous blogs, we have discussed Decorator design pattern and Adapter design pattern. Now, its time to discuss another Structural design pattern i.e. the Proxy design pattern. We will implement the same EUGDPR problem using the Proxy design pattern, which we implemented using the Adapter design pattern in our previous blog. Problem Statement: Earlier, in many applications, all the user-specific details like Continue Reading

Ethereum Networks

Understanding Different kinds of Ethereum Networks

After gulping a lot about the “disrupting” things related to Blockchain technology, I was very intrigued to quickly set up a development environment with whatever is free and useful on the Internet for developing a kick-ass DApp (I am Joking, Just trying “Hello, World!” 😉  I came to learn that “Ethereum” is the most matured protocol around blockchain. Before I proceed further with tools available Continue Reading

kafka with spark

RDD: Spark’s Fault Tolerant In-Memory weapon

A fault-tolerant collection of elements that can be operated on in parallel:  “Resilient Distributed Dataset” a.k.a. RDD RDD (Resilient Distributed Dataset) is the fundamental data structure of Apache Spark which are an immutable collection of objects which computes on the different node of the cluster. Each and every dataset in Spark RDD is logically partitioned across many servers so that they can be computed on Continue Reading

kafka with spark

Spark Unconstructed | Deep dive into DAG

Apache Spark is all the rage these days. People who work with Big Data, Spark is a household name for them. We have been using it for quite some time now. So we already know that Spark is lightning-fast cluster computing technology, it is faster than Hadoop MapReduce. If you ask any of these Spark techies, how Spark is fast, they would give you a Continue Reading

Adapter design pattern with Scala

Hi Readers! In our last blog, we have discussed the Decorator design pattern with Scala. In this blog, we will explore the Adapter design pattern. We will also implement this pattern in Scala. Earlier, in many applications, all the user-specific details like username, IP addresses, phone number, etc were logged directly without scrambling it. But after new data protection law i.e. EUGDPR, it is now Continue Reading

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

Back2Basics: Algebraic Data Types (ADTs)

To understand ADTs, firstly, we have to understand what is the meaning of the word “algebra“. Algebra Algebra is basically the study of mathematical symbols and the rules for manipulating these symbols. So, logically, an algebra can be thought of as consisting of two things: A set of objects The operations that can be applied to those objects to create new objects Numeric algebra Numeric algebra is the Continue Reading

Macros in Rust #2

In my previous blog, we have already discussed what macros and why macros. Now in this blog, we will go through the types of macros in detail. So basically we have two types of macros in Rust language i.e Declarative Macros and Procedural Macros. Declarative Macros: Actually, we can further divide Declarative macros into two parts ones defined with the macro_rules! keyword, and ones defined with the macro Continue Reading

Log Rotate: Managing Your Cluster Log Made Easy

Log Rotation through Ansible to compress log files and save disk space.

%d bloggers like this: