mariotacke

Pattern file: /etc/logstash/patterns/nginx Logstash shipper: /etc/logstash/conf.d/shipper.conf

Nginx http log module: http://nginx.org/en/docs/http/ngx_http_log_module.html

djspiewak

Thread Pools

Thread pools on the JVM should usually be divided into the following three categories:

1. CPU-bound
2. Blocking IO
3. Non-blocking IO polling

Each of these categories has a different optimal configuration and usage pattern.

umidjons

Download Audio from YouTube

-i - ignore errors

-c - continue

-t - use video title as file name

--extract-audio - extract audio track

iamtmrobinson

import * as React from 'react';
import {
  Field as FormField,
  InjectedFormProps,
  reduxForm,
} from 'redux-form';

interface CustomProps {
  customText: string;
}

yingy4

Scala Case class, Companion object, Apply method and more

Let’s take a look at some examples:

Example1:

object Tests extends App {
  println(Rating("PG",13))
  println(Rating.apply("PG",13)) //This is equivalent, so you don't need to explicitly call apply
}

chiller

Ad-hoc polymorphism with the typeclass pattern

from Wikipedia: "Ad hoc polymorphism is a dispatch mechanism: control moving through one named function is dispatched to various other functions without having to specify the exact function being called. Overloading allows multiple functions taking different types to be defined with the same name; the compiler or interpreter automatically ensures that the right function is called. This way, functions appending lists of integers, lists of strings, lists of real numbers, and so on could be written, and all be called append—and the right append function would be called based on the type of lists being appended. This differs from parametric polymorphism, in which the function would need to be written

calvinlfer

// Unhappy with the default behavior of a particular datatype?
// You can override it as you wish, you must write a Diff and merge for the datatype you wish to override

final case class Address(
  streetNumber: Int,
  streetName: String,
  city: String,
  country: String
)

littlenag

Expressive Metaprogramming for Scala 3

Overview

Scala 3 introduces a new macro system that replaces the experimental Scala 2 system with one that should avoid unsoundness, be simpler to use, and simpler for the compiler team to evolve and maintain.

Perhaps the most significant feature missing from Scala 3 today is the lack of support

erdeszt

import zio.prelude.Newtype

import cats.Contravariant
import cats.Functor
import cats.syntax.contravariant.*
import cats.syntax.functor.*

import io.circe.*
import io.circe.syntax.*
import io.circe.parser.decode

johnhungerford

//> using scala 3.3

import scala.util.{Failure, NotGiven, Success, Try, boundary}
import boundary.{Label, break}
import scala.annotation.targetName

/**
 * Proof of concept implementation of a syntax similar to Kotlin and
 * typescript. Within the context provided by [[getEither]], you can call
 * `?` on any optional/failable type (currently supports [[Option]],