Knoldus

[knoldus]

Hello All,

We are experiencing some issues with our hosting due to which the blog is not looking its usual shape. We are working on correcting that soon.

We apologize for the inconvenience.

The post Sorry for the cluttered look appeared first on Knoldus.

[knoldus]

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin maximus vulputate erat vel euismod. Mauris vitae bibendum tortor. Praesent elit velit, venenatis quis elementum non, congue mollis lacus. Maecenas id ante et urna suscipit consectetur. Proin vel ipsum vestibulum, hendrerit orci vel, fringilla neque. Donec sodales, purus vel varius viverra, tellus quam fermentum mi, ut elementum enim magna non eros. Aenean lobortis pulvinar leo, ac feugiat orci pretium quis. Praesent vel velit sed nulla porta ornare lacinia non magna. Aliquam non purus sapien. Pellentesque eget velit vestibulum, ullamcorper nunc eget, lacinia quam. Donec nulla purus, eleifend eget urna sed, ultricies ultricies ex. Morbi justo nisl, luctus a mauris at, placerat ultrices velit. Nam vel vestibulum orci, nec eleifend mi. Vivamus posuere tellus egestas orci placerat, eget egestas odio finibus. Suspendisse eleifend lacus et pellentesque efficitur. Sed diam urna, scelerisque ac ipsum sed, ultrices ultrices turpis. Etiam dictum sed urna quis volutpat. Aliquam pellentesque nunc quis purus semper hendrerit. Integer eu vestibulum ante. Ut tincidunt, ante in aliquet commodo, sapien metus sodales velit, vel pretium quam ex vel diam. Aliquam accumsan molestie odio, ut consequat purus lacinia a. Aenean eget vehicula sem, a euismod augue. Sed ut tincidunt velit. Phasellus et dui at erat consequat tempor id egestas magna. Pellentesque vulputate eleifend leo, sit amet viverra felis venenatis vel. Phasellus consequat et elit eu elementum. Vivamus eu urna nec est malesuada scelerisque. Praesent vel enim ut lorem egestas elementum. Etiam porttitor diam at mollis maximus. Vestibulum ac lobortis neque, vel euismod lectus. Vestibulum sollicitudin eget nulla ac sollicitudin. Vivamus non turpis ut mauris scelerisque fermentum. Ut interdum nibh eget ligula eleifend porta. Etiam quis ultrices lacus, non vestibulum lacus. Suspendisse venenatis elit vel ipsum laoreet, a porta nulla dignissim. Fusce imperdiet et orci ac rutrum. Proin accumsan enim non ipsum faucibus, ut bibendum justo mattis. In laoreet rutrum commodo. Suspendisse egestas tellus in libero aliquam maximus non nec metus. Vestibulum molestie sollicitudin felis consectetur viverra. Proin non nibh ullamcorper, dignissim nunc quis, consequat enim. Vivamus suscipit ante nunc, non dictum odio ullamcorper non. Etiam eu lorem eu diam pulvinar porta vel nec lorem. Suspendisse at neque lectus.

[knoldus]

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin maximus vulputate erat vel euismod. Mauris vitae bibendum tortor. Praesent elit velit, venenatis quis elementum non, congue mollis lacus. Maecenas id ante et urna suscipit consectetur. Proin vel ipsum vestibulum, hendrerit orci vel, fringilla neque. Donec sodales, purus vel varius viverra, tellus quam fermentum mi, ut elementum enim magna non eros. Aenean lobortis pulvinar leo, ac feugiat orci pretium quis. Praesent vel velit sed nulla porta ornare lacinia non magna. Aliquam non purus sapien. Pellentesque eget velit vestibulum, ullamcorper nunc eget, lacinia quam. Donec nulla purus, eleifend eget urna sed, ultricies ultricies ex. Morbi justo nisl, luctus a mauris at, placerat ultrices velit. Nam vel vestibulum orci, nec eleifend mi. Vivamus posuere tellus egestas orci placerat, eget egestas odio finibus. Suspendisse eleifend lacus et pellentesque efficitur. Sed diam urna, scelerisque ac ipsum sed, ultrices ultrices turpis. Etiam dictum sed urna quis volutpat. Aliquam pellentesque nunc quis purus semper hendrerit. Integer eu vestibulum ante. Ut tincidunt, ante in aliquet commodo, sapien metus sodales velit, vel pretium quam ex vel diam. Aliquam accumsan molestie odio, ut consequat purus lacinia a. Aenean eget vehicula sem, a euismod augue. Sed ut tincidunt velit. Phasellus et dui at erat consequat tempor id egestas magna. Pellentesque vulputate eleifend leo, sit amet viverra felis venenatis vel. Phasellus consequat et elit eu elementum. Vivamus eu urna nec est malesuada scelerisque. Praesent vel enim ut lorem egestas elementum. Etiam porttitor diam at mollis maximus. Vestibulum ac lobortis neque, vel euismod lectus. Vestibulum sollicitudin eget nulla ac sollicitudin. Vivamus non turpis ut mauris scelerisque fermentum. Ut interdum nibh eget ligula eleifend porta. Etiam quis ultrices lacus, non vestibulum lacus. Suspendisse venenatis elit vel ipsum laoreet, a porta nulla dignissim. Fusce imperdiet et orci ac rutrum. Proin accumsan enim non ipsum faucibus, ut bibendum justo mattis. In laoreet rutrum commodo. Suspendisse egestas tellus in libero aliquam maximus non nec metus. Vestibulum molestie sollicitudin felis consectetur viverra. Proin non nibh ullamcorper, dignissim nunc quis, consequat enim. Vivamus suscipit ante nunc, non dictum odio ullamcorper non. Etiam eu lorem eu diam pulvinar porta vel nec lorem. Suspendisse at neque lectus.

[knoldus]

Crochet Dinamite

[knoldus]

What is Lorem Ipsum?

Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry’s standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.

Why do we use it?

It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using ‘Content here, content here’, making it look like readable English. Many desktop publishing packages and web page editors now use Lorem Ipsum as their default model text, and a search for ‘lorem ipsum’ will uncover many web sites still in their infancy. Various versions have evolved over the years, sometimes by accident, sometimes on purpose (injected humour and the like).

Where does it come from?

Contrary to popular belief, Lorem Ipsum is not simply random text. It has roots in a piece of classical Latin literature from 45 BC, making it over 2000 years old. Richard McClintock, a Latin professor at Hampden-Sydney College in Virginia, looked up one of the more obscure Latin words, consectetur, from a Lorem Ipsum passage, and going through the cites of the word in clas

[knoldus]

What is Lorem Ipsum?

Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry’s standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.

Why do we use it?

It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using ‘Content here, content here’, making it look like readable English. Many desktop publishing packages and web page editors now use Lorem Ipsum as their default model text, and a search for ‘lorem ipsum’ will uncover many web sites still in their infancy. Various versions have evolved over the years, sometimes by accident, sometimes on purpose (injected humour and the like).

Where does it come from?

Contrary to popular belief, Lorem Ipsum is not simply random text. It has roots in a piece of classical Latin literature from 45 BC, making it over 2000 years old. Richard McClintock, a Latin professor at Hampden-Sydney College in Virginia, looked up one of the more obscure Latin words, consectetur, from a Lorem Ipsum passage, and going through the cites of the word in clas

[knoldus]

jwilahfliwfijijl;ajlkjfelkLFKEJL

[knoldus]

yygjhiuhkhkjhkh gvhhjbjkh vhjgbmhhjhkhkh

[knoldus]

This is your very first post. Click the Edit link to modify or delete it, or start a new post. If you like, use this post to tell readers why you started this blog and what you plan to do with it.

[knoldus]

This is a featured content post. Click the Edit link to modify or delete it, or start a new post.

[knoldus]

This is a featured content post. Click the Edit link to modify or delete it, or start a new post.

[knoldus]

Why Rust? 

In system programming languages we basically face two complex problems which are difficult to crack i.e. Secure and Multithreaded code. For this Rust has added its own goals of memory safety and data-race-free concurrency.

What Is Rust? 

Rust is a System programing language sponsored by Mozilla which describes it as a “safe,  concurrent and practical language,” supporting functional and imperative-procedural paradigms. It basically focused on three goals i.e. safety, speed, and concurrency.

Rust Prerequisites: 

Syntax: Rust has a concrete syntax similar to C and C++. The blocks of code are delimited by curly brackets, and control flow keywords such as if, else, while and for. Also, there are some new keywords are also introduced such as match(for pattern matching).

Memory safety: Rust is designed to be memory safe and it does not allow null pointers, dangling pointers, or data safe in safe code. Rust core library also provides an option type.

Memory Management: In Rust, there is no automated garbage collection like  Java and other languages.

Hello World Example:

First, we will create a file named main.rs(.rs  is the extension for Rust). And then will write the following the below code.

fn main(){ println!(“Hello World, Welcome to Rust”); }

Now we will run this code snippet with the following command:

$ rustc main.rs $ ./main

Output: Hello World, Welcome to Rust

Above is  hello world code in rust, now we will see what just happen in your “Hello World, Welcome to Rust” program in detail:

In the first line ‘fn’ defines a function in Rust, ‘main’ function is special as it is the beginning for every code in Rust. Here this function doesn’t return any value and also don’t take an argument.

In the second line ‘println!()’ is calling Rust macro, which is how metaprogramming is done in Rust. In Rust when we see ‘!’ means that that is a macro instead of normal function.

Variables In Rust:

In Rust, we use variable binding for assigning a value to a name. Like

let x = 20;

Here x is a variable which is assigned a value 20. But here let is a pattern, not a name i.e we can also use pattern in this way:

let (x, y) = (3, 4);

This means x is 3 and y is 4. By default, a variable is immutable in Rust. That means in, let x = 20;  x is immutable and if we need to make the variable mutable we have to use the mut keyword as explained below

let mut x = 20;  // here x is mutable.

There are many features in Rust which can’t be shared on a single blog so we will be discussing that in my future blogs.

References:

https://en.wikipedia.org/wiki/Rust_(programming_language) https://doc.rust-lang.org/book/second-edition/index.html

[knoldus]

You must be wondering what is so special about numeric data types in RUST, that we are focusing on them so much, definitely, you will get to know after finishing this blog.

Generally, other programming languages follow short, int, float, long, double etc as numeric data types as per their storage size and capacity while in RUST numeric data type are like :

i[size_in_bits] or u[size_in_bits] 

Here, i or u stands for signed and unsigned numbers respectively. Size in bits (in multiple of 8bits) means the storage size and minimum/maximum numeric value it can hold.

Note: By default, i32 is the integer data type, in case you don’t specify.

If you don’t have any idea how to calculate the size in bits to specify, you can calculate using the following formulae for the signed number where n is no of bits:

 -(2n – 1) to 2n – 1 – 1 -> which equals -128 to 127 for n = 8

For unsigned it will be:

0 to 2n – 1 -> which equals 0 to 255 for n = 8

Below Tables show the different integer numeric data types in RUST:

Length Signed Unsigned 8-bit i8 u8 16-bit i16 u16 32-bit i32 u32 64-bit i64 u64 CPU Arch (32/64 bits) isize usize

We haven’t mentioned anything about decimals/real numbers, as above all mentioned data type will only hold the integer value. So to deal with floating values, RUST provides us data type in the same above-mentioned manner.

Rust’s floating-point types are f32 and f64, which are 32 bits and 64 bits in size, respectively. f32 type is a single-precision float and f64 has double precision.

Note: By default, f64 is the floating data type, in case if you don’t specify as in current system all are 64 bits CPU, as it hardly make any difference in performance and it is capable of double precision as well.

So, by now you must have understood what’s the big difference in RUST while dealing with numeric data type whether it’s integer or floating.

[knoldus]

Every language has its own toolset for writing effective and clean code, Rust is no different. So in this blog, we would be describing how to format the rust code, while working with different editors or IDE.

Formatting code is a mechanical task which takes both time and mental effort. By using an automatic formatting tool, a programmer is relieved of this task and can concentrate on more important things. Furthermore, by sticking to an established style guide, programmers don’t need to formulate ad hoc style rules. Having consistent, standardized automated code styling in a project can be useful for code review, attracting new contributors, and avoiding unproductive discussions.

So here, we will be discussing the following scenarios:

Using default text-editors.

Using Sublime.

Using Atom.

Using IDE (like IntelliJ or Eclipse).

Prerequisite: We are considering that rust and cargo are already installed in your system. Please follow the blog RUST: Quick Start & Exploring Cargo to install rust and cargo if you haven’t got a chance to install them.

Scenario 1: Using a default text editor

While using a default editor, it’s difficult for developers to work on business logic and actual code while keeping an eye on the coding style.  So for making the developer’s job easier, we can use the following tools:

RustFmt: 

Rustfmt is a tool for formatting Rust source code. You can install it using Cargo:

$ cargo install rustfmt

This will install an executable into ~/.cargo/bin/. In order to use it, add it into your $PATH variable. In case you are using Bash, follow these steps:

$ echo ‘export PATH=$PATH:$HOME/.cargo/bin’ >> $HOME/.bashrc $ source $HOME/.bashrc

Now you can use rustfmt to format either a single file or the whole project: Single file:

    $ rustfmt src/main.rs

Project:

    $ cargo fmt

Note 1: If Rustfmt crashes during formatting, please get a backtrace by re-running with

RUST_BACKTRACE=1

Note 2: Some code will need fixing up after Rustfmt is done. There are two reasons for this: in some places, Rustfmt won’t reformat the code yet, but it moves around surrounding code in a way which makes this a problem. In other places you might want non-standard formatting, for example, if you have a 3×3 array which represents a matrix, you might want this on three lines even though rustfmt can fit it on one line. Note 3: you can use the #[rustfmt_skip] attribute. This can be placed on functions, modules, and most other items. Again, after fixing up the source code and adding the attribute, check that Rustfmt does not make any further changes. Note 4:At this point we can run cargo fmt to format a repository. It runs rustfmt in the ‘replace’ mode which creates backup files with a .bk extension. If our project is already in version control we may not want this. If that is the case we can edit rustfmt.toml to include the following:

$ write_mode = “overwrite”

Note 5: The rustfmt.toml lets us configure the various options found in

$ rustfmt –config-help.

Clippy

The Rust compiler is already quite strict, clippy goes a step further and helps prevent some things which are valid but bad practice. This can help prevent unexpected problems later in your code. Clippy requires nightly in order to run. If it’s not installed please install that first. Once nightly is installed, we could use the following command:

$ cargo +nightly install clippy

Now we can run clippy with the following command:

$ cargo +nightly clippy

Racer:

Racer saves us some time looking through documentation and helps us discover functionality as we type. Racer is a code completion utility that’s used in various editor addons. First, install it:

$ cargo install racer

Next we need to set an environment variable so racer knows where to look for the Rust source. In your ~/.bashrc (or ~/.zshrc etc) add the following line: # Mac

export RUST_SRC_PATH=${HOME}/.rustup/toolchains/stable-x86_64-apple-darwin/lib/rustlib/src/rust/src

# Linux

export RUST_SRC_PATH=${HOME}/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/src

Then you can test that racer works by doing a test run via the command line:

$ racer complete std::io::B

Scenario 2: Using Sublime as the editor

While using sublime editor, we have following steps to be followed, to get the maximum out of it:

Step 1: Go to View, move to Syntax and select Rust.

Step 2: To select the build system, go to Tools, hover on to the Build System and select Rust.

Step 3: Setup Anaconda_Rust package: Anaconda Rust offers auto completion, auto formatting and linting for Rust language that will never freeze your Sublime Text 3. Follow the steps in the link, to add the package.

And now you are ready to use Sublime as your regular rust programming editor.

Scenario 3: Using Atom as the editor

Atom has a lot of packages to look into and here are the few that could be used:

– rustfmt – racer – language-rust – linter-rust – rust-api-docs-helper – languageserver-rust – build-cargo – autocomplete-crates

Go through them and you will feel blessed to have these packages along your side while working with Atom to write Rust codes.

Scenario 4: Using IntelliJ IDE

IntelliJ provides a Rust plugin that would ease a developer’s life while working on Rust. Like for other languages, we get the same help in IntelliJ for rust, syntax highlighting, code formatting, code selection, code completion, source code navigation etc. For detailed features please visit the link.

Hope this blog would be helpful for you while choosing your editor for Rust programming and using the power of the editors’ packages and plugins.

For more blogs regarding Rust, keep going through our blogs, because we at Knoldus believe in working on the cutting-edge technologies and help out the community of tech-enthusiasts by sharing our experiences and knowledge.

[knoldus]

In Angular, we can use either Promise or Observable for handling asynchronous data. Both get and post method of Http and HttpClient return Observable and it can be converted into Promise using toPromise() method. So, what’s the difference when they both are dealing with asynchronous data.

What actually the difference is:

Promise emits a single value while Observable emits multiple values. So, while handling a HTTP request, Promise can manage a single response for the same request, but what if there are multiple responses to the same request, then we have to use Observable. Yes, Observable can handle multiple responses for the same request. Let’s implement this with an example.

Promise:

const promise = new Promise((data) => { data(1); data(2); data(3); }).then(element => console.log(‘Promise  ‘ + element));

Output:

Observable:

const observable = new Observable((data) => { data.next(1); data.next(2); data.next(3); }).subscribe(element => console.log(‘Observable ‘ + element));

Output:

So, in the above code snippet, I have created promise and observable of Promise and Observable type respectively. But, promise returns the very first value and ignore the remaining values whereas Observable return all the value and print 1, 2, 3 in the console.

Promise is not lazy while Observable is lazy. Observable is lazy in nature and do not return any value until we subscribe.

home.component.ts (Observable)

getMenu() { this.homeService.getFoodItem(); } }

In above example we are not subscribing the observable, so we do not receive the data and even there would be a no network call for this service.

home.component.ts (Observable)

getMenu() { this.homeService.getFoodItem().subscribe((data  => { this.foodItem = data; }), error => console.log(error)); } }

Here, we have subscribed our Observable, so it will simply return the data. But Promise returns the value regardless of then() method.

home.component.ts (Promise)

getMenu() { this.homeService.getFoodItem() .then((data) => { this.foodItem = data; }); }

Observable is cancellable in nature by invoking unsubscribe() method, but Promise is not cancellable in nature.

Hope this is helpful and give you a basic understanding of how Promise differs from Observable. Please feel free to provide your suggestions

References:

http://csharp-video-tutorials.blogspot.com/2017/09/angular-promises-vs-observables.html https://medium.com/@mpodlasin/promises-vs-observables-4c123c51fe13

[knoldus]

  This blog will guide you through the basic understanding of extractors in scala.

An extractor is an object that has an unapply method. It takes an object as an input and gives back arguments. Custom extractors are created using the unapply method. The unapply method is called extractor because it takes an element of the same set and extracts some of its parts,  apply method also called injection acts as a constructor, takes some arguments and yields an element of a given set.

A case class in Scala, by default implements, apply and unapply methods.

Case Classes are special because Scala automatically creates a companion object for them: a singleton object that contains not only an apply method for creating new instances of the case class but also an unapply method that needs to be implemented by an object in order for it to be an extractor.

case class Blog (name: String, length: Int)

“apply”  method is called while instantiating case class :

val blog = Blog("extractor", 140)

val name = Blog.unapply(blog).get is same as:

val Blog(name,length) = blog

Let’s understand extractors using examples:

The return type of an unapply should be chosen while keeping following things in mind:

If it returns a single sub-value of type T, return a Option[T].

If it is just a test, return a Boolean.

If you want to return several sub-values T1,...,Tn, group them in an optional tuple Option[(T1,...,Tn)].

Let’s discuss all three points one by one:

When no value matches in case, match error is thrown.

SINGLE SUB-VALUE

object Math { def apply(number: Int): Int = number * number def unapply(number: Int): Option[Int] = { if (number % 2 == 0) Some(number / 2) else None } } val obj = Math (2) val objectOne = Math (1) //match error is thrown obj match { case Math (number) => // invoke Math.unapply println (number) // prints 2 }

val object = Math(2) expands to val object = Math.apply(2)

SEVERAL SUB-VALUES

object DemoAddr { def unapply(addr: String): Option[(String, String, String, String)] = { val tokens = addr split "\\." if (tokens.length == 4) Some(tokens(0), tokens(1), tokens(2), tokens(3)) else None } } "127.0.0.1" match { case DemoAddr (addr, _, _, _) => println ("matched!!" + addr) } // prints matched!!127

BOOLEAN VALUE

def unapply (addr: String): Boolean = { val tokens = addr split "\\." if (tokens.length == 4 && isValid (tokens) ) true else false } "127.0.0.1" match { case DemoAddr () => println ("Valid") // prints Valid case _ => println ("Invalid") }

If you have a variable number of argument values, scala gives an extractor method unapplySeq.

object DemoAddresses { def unapplySeq(ips: String): Option[Seq[String]] = { Some(ips split ",") } } "192.168.0.1,192.168.0.2,192.168.0.3,192.168.0.4" match { case DemoAddrress (DemoAddr (a, _, _, _), DemoAddr (b, _, _, _), _*) => println (a + " " + b) case _ => println ("Invalid IP addresses") } // prints 192 192

Let’s understand the order in which extractors are called:

object EMailValidator { def apply(user: String, domain: String) = user + "@" + domain def unapply(str: String): Option[(String, String)] = { val parts = str split "@" if (parts.length == 2) Some(parts(0), parts(1)) else None } } object Twice { def apply(str: String): String = str + str // concatenates string with itself def unapply(str: String): Option[String] = { val length = str.length / 2 val half = str.substring(0, length) if (half == str.substring(length)) Some(half) else None } object UpperCase { def unapply(str: String): Boolean = str.toUpperCase == str // returns true if string is in uppercase else false } def userTwiceUpper(s: String) = s match { case EMailValidator(Twice(x@UpperCase()), domain) => "match:" + x + "in domain" + domain case => "no match" }

  EMailValidator(Twice(x @ UpperCase()), domain) order of calling is from left to right.

EmailValidator divides “[email protected]” into “DIDI” and “hotmail.com” (user and domain). Twice will be called on the user and unapply  method will convert it to “DI”. Uppercase will be called on DI and true will be returned. The result will be:

 match: DI in domain hotmail.com

Extractors do not expose the concrete representation of data. They enable patterns without any relation to the data type for the selected object.

Thanks for reading!

[knoldus]

Scala Days was held on June 17-21 in NYC and hosted by Lightbend, which brings together hundreds of like-minded Scala developers, engineers, and sponsors from around the world to exchange info, learn from keynotes and to celebrate Scala community. Did you miss the event? Don’t worry; we’ve got you covered.

Vikas Hazrati and Ram Indukuri from Knoldus Inc. attended Scala Days 2018, New York and learned the keynotes and panel sessions were packed with technical deep dives and demos from experts.

The event started with the keynote by Scala creator Martin Odersky on “ Preparing for Scala 3 ”. He discussed the next version of Scala, 2.13 and gave an overview of the improvements in tooling and the standard library. The planned steps after this release were directed towards Scala 3. This will be an important transition for the Scala ecosystem, introducing a simpler, more regular, and more expressive version of the language.  You can access the whole keynote of Martin Odersky from here.

The other interesting note is “Scala Is for Everyone”. As the topic suggested, everyone can learn Scala who have a little or no CS background adopting the Scala language on workshops, kids understanding FP basis. Anyone who has a desire can learn Scala. You can watch the whole keynote from here.

Another interesting session was by Neha Narkhede (Co-founder and CTO at Confluent). This talk explained how companies are taking advantage of real-time data by leveraging the concepts of events and streams to transform their business to meet the demands of the digital future. Apache Kafka serves as the foundation to streaming data applications.

            She also explained how KSQL, Connect, and the Streams API with Apache Kafka capture the entire scope of what it means to put real time into practice. To get the slides, please click here.

All of the sessions were recorded and are available here.

Knoldus Booth at Scala Days, New York

Knoldus Inc. was the Gold Sponsor at Scala Days, New York. Vikas & Ram from Knoldus were present at the booth and discussed how reactive application is going to play an important role in the near future.  our unique approach (Knolway) that enables us to combine key capabilities to deliver disruptive, scalable and innovations for clients by leveraging Lightbend, Inc. platform.

                    We also showcased the live demo of CodeSquad at our booth. With the help of CodeSquad, you can have qualitative analysis and insight into the projects by highlighting any missing or problematic attributes. Features of CodeSquad are:

Continuous Quality Check

Visualise the history of a project

Graphs and visualizations to track project quality

Real-time notifications

We also distributed corporate swag – Stickers, Camera Blockers, and  MousePad to all the excited visitors at the booth.

Our company continues to expand, offering many exciting and challenging opportunities to fuel the digital complex transformation. If you couldn’t make it to our booth then don’t worry we still have the opportunities available for the position of Lead Consultant, so feel free to send your resume at [email protected]  

With all this Scala Days has come to an end and it was an amazing few days. Now, let’s get back to work and see what Scala 3 will brings to the table, and we’re looking forward to it.

Drop us a line to discover how we are leveraging Scala ecosystem and delivering solutions that designed to last and improve business performance.