Jules Ivanic guizmaii

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

How to use NonEmptyList in a model class

Let's say you are implementing an API and decide to return a base error response in common error situations such as BadRequest, NotFound etc.

final case class Error(code: String, description: String)

If you are returning an error response, your assumption would probably be that such responses should contain at least one error.

If you want to learn Scala, I’d suggest:

Install IntelliJ + Scala Plugin
Don’t do the Coursera courses yet.
Don’t do the “red book” Functional Programming in Scala yet.
Do: http://underscore.io/books/
- Essential Scala
- Essential Play
- Essential Slick
Do Scala for the Impatient: https://www.amazon.com/Scala-Impatient-Cay-S-Horstmann/dp/0321774094
The Neophyte’s Guide to Scala http://danielwestheide.com/scala/neophytes.html

Revisiting Tagless Final Interpreters

Tageless Final interpreters are an alternative to the traditional Algebraic Data Type (and generalized ADT) based implementation of the interpreter pattern. This document presents the Tageless Final approach with Scala, and shows how Dotty with it's recently added implicits functions makes the approach even more appealing. All examples are direct translations of their Haskell version presented in the Typed Tagless Final Interpreters: Lecture Notes (section 2).

The interpreter pattern has recently received a lot of attention in the Scala community. A lot of efforts have been invested in trying to address the biggest shortcomings of ADT/GADT based solutions: extensibility. One can first look at cats' Inject typeclass for an implementation of [Data Type à la Carte](http://www.cs.ru.nl/~W.Swierstra/Publications/DataTypesA

	import java.util.concurrent.TimeUnit

	import org.openjdk.jmh.annotations._
	import org.openjdk.jmh.infra.Blackhole

	import scala.util.Random

	@State(Scope.Benchmark)
	@BenchmarkMode(Array(Mode.AverageTime))
	@OutputTimeUnit(TimeUnit.MICROSECONDS)

	#!/usr/local/bin/amm

	import sys.process._
	import collection.mutable
	import ammonite.ops._
	import ammonite.ops.ImplicitWd._

	import $ivy.`com.amazonaws:aws-java-sdk:1.11.204`

	import com.amazonaws.services.cognitoidp._

	import java.util.concurrent._
	import akka.dispatch.{Dispatcher, ExecutorServiceDelegate}
	import config.Config
	import helpers.ScalaLogger

	class ExecutionContextMonitor()(implicit metricsService: MetricsClient, config: Config) {
	private val log = ScalaLogger.get(this.getClass)

	private val scheduler = Executors.newSingleThreadScheduledExecutor()

	// How to install it:
	// ------------------
	//
	// 1. Copy this function into your .zshrc or .bashrc file
	// 2. Done!
	//
	// How to use it:
	// --------------
	//
	// You want to merge `develop` branch in your `my_functionnality` branch.

	import cats.instances.future._
	import cats.instances.option._
	import cats.syntax.traverse._
	import cats.syntax.cartesian._

	import scala.concurrent.Future

	trait Guizmaii {

	import scala.concurrent.ExecutionContext.Implicits.global

	#!/bin/bash

	curl https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/AmazonEC2/current/index.json \| jq -r '.products[].attributes["instanceType"]' \| sort -u \| grep '\.'