calvinlfer

val (recycleQueue, recycleSource) =
  Source
    .queue[SoilStateReading](100, OverflowStrategy.dropTail)
    .prefixAndTail(0)
    .map(_._2)
    .toMat(Sink.head)(Keep.both)
    .run()
StreamConverters.fromInputStream(() => this.getClass.getClassLoader.getResourceAsStream("sensors.log"))
  .via(SoilStateReading.csvParser)
  .merge(Source.fromFutureSource(recycleSource))

calvinlfer

Quick Tips for Fast Code on the JVM

I was talking to a coworker recently about general techniques that almost always form the core of any effort to write very fast, down-to-the-metal hot path code on the JVM, and they pointed out that there really isn't a particularly good place to go for this information. It occurred to me that, really, I had more or less picked up all of it by word of mouth and experience, and there just aren't any good reference sources on the topic. So… here's my word of mouth.

This is by no means a comprehensive gist. It's also important to understand that the techniques that I outline in here are not 100% absolute either. Performance on the JVM is an incredibly complicated subject, and while there are rules that almost always hold true, the "almost" remains very salient. Also, for many or even most applications, there will be other techniques that I'm not mentioning which will have a greater impact. JMH, Java Flight Recorder, and a good profiler are your very best friend! Mea

calvinlfer

import com.github.t3hnar.bcrypt._

// Phantom type used in detecting questions and credentials using plain or hashed passwords
sealed trait PasswordStatus
trait Plain extends PasswordStatus
trait Hashed extends PasswordStatus

case class SecretQuestion[Status <: PasswordStatus](memberId: UUID, questionId: String, answer: String)

object SecretQuestion {

calvinlfer

import scala.annotation.tailrec

sealed trait UsEast1AvailabilityZone
case object UsEast1a extends UsEast1AvailabilityZone
case object UsEast1b extends UsEast1AvailabilityZone
case object UsEast1c extends UsEast1AvailabilityZone

type Count = Int
def distribute(nrOfAsgs: Int, regions: List[UsEast1AvailabilityZone]): Map[UsEast1AvailabilityZone, Count] = {
  @tailrec

calvinlfer

scalaVersion := "2.12.4"

libraryDependencies ++= {
  val akkaHttpV = "10.0.11"
  val circeV = "0.9.1"
  Seq(
    "com.typesafe.akka"   %% "akka-http"                   % akkaHttpV,
    "io.circe"            %% "circe-core"                  % circeV,
    "io.circe"            %% "circe-generic"               % circeV,
    "io.circe"            %% "circe-parser"                % circeV,

calvinlfer

import akka.actor.ActorSystem
import akka.pattern.after

import scala.concurrent.{ExecutionContext, Future}
import scala.concurrent.duration._

val system: ActorSystem = ActorSystem()
implicit val ec: ExecutionContext = system.dispatcher

val fallback: Future[Option[Int]] = after(2.seconds, system.scheduler)(Future.successful(None))

calvinlfer

#!/bin/bash -l

# find latest backup
thinbackup_path="$JENKINS_HOME/thinBackup"
latest_backup_folder=$(ls -t $thinbackup_path | head -n1)
full_path="$thinbackup_path/$latest_backup_folder"
echo "Latest backup is located at ${full_path}"

# pack it up
backup_name="$latest_backup_folder.tar.gz"

calvinlfer

import java.time.{ZoneId, ZonedDateTime}
import java.time.format.DateTimeFormatter

import ammonite.ops._

import scala.concurrent._
import duration._

object AmmoniteFun extends App {
  implicit val path: Path = pwd

calvinlfer

import scala.io.StdIn
import scala.language.higherKinds
import scala.util.Try

object Practice extends App {

  trait Program[F[_]] {
    def finish[A](a: => A): F[A]

    def chain[A, B](fa: F[A], afb: A => F[B]): F[B]

calvinlfer

import fs2._

def myTake[F[_], A](nrOfElements: Int): Pipe[F, A, A] = inputStream => {
  def go(s: Stream[F, A], remaining: Int): Pull[F, A, Unit] =
    if (remaining == 0) Pull.done
    else s.pull.uncons1.flatMap {
      case Some((element: A, remStream: Stream[F, A])) => Pull.output1(element) >> go(remStream, remaining - 1)
      case None => Pull.done
    }