dorsev

Scala gives us the sealed keyword, which allows the compiler to check at compile time that all cases of a type have been handled with So the compiler checks in compile-time - yes. - compile-time -that you handled all the cases.

Why is this insanely useful(IMO - the biggest advantages of scala over a lot of languages): let's take an example: When you write a calculator

Sealed trait Expression {
 case class Add(left:Int,right:Int) extends Expression

dorsev

package wordCount

import java.io._

import zio._
import zio.console._
import zio.stream.{ZStream, ZTransducer}

object wordCount extends zio.App {
  def run(args: List[String]) =

dorsev

{
 "compilerOptions": {
   "target": "esnext",
   "module": "commonjs",
   "allowJs": true,
   "checkJs": false,
   "outDir": "dist",
   "rootDir": ".",
   "strict": false,
   "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,

dorsev

A complete list of the metrics and names I added were:
latency metrics list
processing_duration_ms - histogram - which measures processing latencies.
deserialize_duration_ms - histogram - which measures how long it takes to deserialize a request
serialize_duration_ms - histogram - which measures how long it takes to serialize an event
store_duration_ms - histogram - which measures how long it takes to store(index/save/persist) a state change.
with all of these, I can now define a total_processing_duration_ms which will be deserialize_duration_ms + serialize_duration_ms + store_duration_ms + processing_duration_ms

Applicative usage metrics
incoming_requests_count - counter - which will indicate how many requests did we process. Using this metric we can define throughput!

dorsev

import SDC = require("statsd-client");
let sdc = new SDC({ host: 'localhost' });
let senService: SentimentAnalysisService; //...
while (true) {
    let tweetInformation = kafkaConsumer.consume()
    sdc.increment('incoming_requests_count')
    let deserializedTweet: { msg: string } = deSerialize(tweetInformation)
    sdc.histogram('request_size_chars', deserializedTweet.msg.length);
    let sentimentResult = senService.calculateSentiment(deserializedTweet.msg)
    if (sentimentResult !== undefined) {

dorsev

let senService: SentimentAnalysisService = new SentimentAnalysisService();
while (true) {
    let tweetInformation = kafkaConsumer.consume()
    let deserializedTweet: { msg: string } = deSerialize(tweetInformation)
    let sentimentResult = senService.calculateSentiment(deserializedTweet.msg)
    let seriarliedSentimentResult = serialize(sentimentResult)
    sentimentStore.store(sentimentResult);
    kafkaProducer.produce(seriarliedSentimentResult, 'sentiment_topic', 0);
}

dorsev

function multiplesOf3and5(number) {
  return [...Array(number).keys()].filter((x) => {
    if(x % 3 == 0 || x % 5 == 0){
      return x;
    } else return 0;
  }).reduce((agg,elem) => agg+elem, 0);
}

dorsev

curl -X PUT "localhost:9200/my_index_2?pretty" -H 'Content-Type: application/json' -d'
{
    "mappings": {
        "_doc": {
            "properties": {
                "tags": {
                    "type": "object",
                    "properties": {
                        "keyToValue": {
                            "type": "keyword"

dorsev

curl -X PUT "localhost:9200/my_index?pretty" -H 'Content-Type: application/json' -d'
{
        "mappings": {
            "_doc": {
            "properties": {
            "tags": {
                "type": "nested" 
                }                
            }
        }

dorsev

curl -X GET "localhost:9200/_search?pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "match" : {
            "actions.tags.name" : {
                "query" : "John"
            }
        }
    }