debasishg

Thinking differently between frameworks with concrete abstractions (ZIO in Scala) and those with algebras and typeclasses (Haskell / cats & cats-effects in Scala) :-

Using Haskell or Scala cats / cats-effect, which offers libraries based on algebras and typeclasses, we think in terms of the algebra and the appropriate typeclass to model the effect. It's always algebra first - in the following example, we fetch an entity to work with in a domain model. We try fetching from the cache first and if we get a cache miss we reach out for a database based query. With Haskell or cats in Scala, the mantra is using the algebra of an Alternative typeclass.

getAccount = runMaybeT $
      MaybeT (AC.fetchCachedAccount ano) 
  <|> MaybeT (AR.queryAccount ano)

debasishg

1. Courses and MOOCs

• Introduction to Convex Optimization MITOCW by Prof. Stephen Boyd
• Convex Analysis and Optimization MITOCW by Prof. Dimitri Bertsekas
• Convex Optimization MOOC from Stanford Online
• Convex Optimization at CMU Spring 2015

2. Books

• Convex Optimization – Boyd and Vandenberghe - downloadable book
• Convex Optimization Theory - by Dimitri P. Bertsekas
• Theory of Convex Optimization for Machine Learning - download

debasishg

package zio

case class ZKleisli[-R, +E, -A, +B](
    run: A => ZIO[R, E, B]
) { self =>
  // compose with a ZIO not lifted into a Kleisli
  def mapZIO[R1 <: R, E1 >: E, A1 <: A, C1](bc: B => ZIO[R1, E1, C1]): ZKleisli[R1, E1, A, C1] =
    ZKleisli(self.run(_).flatMap(bc))

  // Modify the output of the Kleisli function with `f`

debasishg

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.

debasishg

import cats.{Applicative, Functor}
import cats.syntax.all._

/** Is this the proper Scala encoding for the Haskell snippet in comments ? */
/** from : https://doisinkidney.com/pdfs/algebras-for-weighted-search.pdf */

/** with help from @Odomontois */

// newtype Cayley f a = Cayley {runC :: ∀b. f b → f (a, b) }
trait Cayley[F[_], A] {

debasishg

import cats.{ Applicative, Functor }
import cats.syntax.all._

/** Is this the proper Scala encoding for the Haskell snippet in comments ? */
/** from : https://doisinkidney.com/pdfs/algebras-for-weighted-search.pdf */

// newtype Cayley f a = Cayley {runC :: ∀b. f b → f (a, b) }
sealed trait Cayley[F[_], A] {
  def apply[B](fb: F[B]): F[(A, B)]
}

debasishg

package interview

object DominoInterview extends App {
	/**
	|1|2|3|
	|4|5|6|
	|7|8|9|
	|*|0|#|

	Problem:

debasishg

trait Coercible[A, B] {
  def coerce(a: A): B
}

def coerce[A, B](a: A)(implicit coerceAB: Coercible[A, B]): B = {
  coerceAB.coerce(a)
}

trait Newtype[+T] {
  val value: T

debasishg

  // Inspired by a tweet from @trautonen 1/13/2016
  // Use Source.unfoldAsync to turn paginated database results into an akka-streams Source
  // unfold is the inverse of fold

  case class Page[T](pageNumber:Long, totalPages:Long, contents:List[T])
  case class Thing(id: Long, name: String = "foo")
  
  val totalPages = 5 // 
  val pageSize = 3

debasishg

import org.scalatest._
import org.scalatest.concurrent.ScalaFutures
import scala.concurrent.Future

// from https://github.com/d6y/scalatest-future-failure/blob/master/src/test/scala/example.scala
class ExampleSpec extends FlatSpec with Matchers with ScalaFutures {

  sealed trait Boom extends Throwable
  final case class ExampleFail() extends Boom