programaker

Git worktree workflow

Start a project

Clone or create a new project using gitwt.

It uses a "bare repository" strategy. This way, there's a clear root for the project and there's no need to clone everything - new worktrees only duplicate code, git database stuff remains in a single place.

Work on a task (new branch)

programaker

#!/bin/zsh

# Usage:
#   gitwt <git-uri>              Clone an existing repo into a worktree setup
#   gitwt -c <project-name>      Create a new project from scratch with worktree setup
#
# Examples:
#   gitwt git@github.com:commercetools/the-repo-i-want-to-clone.git
#   gitwt -c my-new-project

programaker

# Replacing Docker Desktop with Colima

https://jacobtomlinson.dev/posts/2022/goodbye-docker-desktop-for-mac-hello-colima/
https://github.com/abiosoft/colima
https://github.com/abiosoft/colima/blob/main/docs/FAQ.md#docker-socket-location

It allows us to keep using docker and docker-compose normally, which is good for legacy scripts.

---

programaker

import cats.effect.IO

def doThings(things: List[Int]): IO[List[Either[Throwable, String]]] = {
  import cats.syntax.traverse._

  things.traverse { i =>
    if (i % 2 == 0)
      IO(Right(s"$i = yay!"))
    else
      IO(Left(new Exception(s"$i = oh no!")))

programaker

import scala.util.Try
import cats.Functor
import cats.Align
import cats.data.Ior

type Decimal = Int
type Roman = String

def f[F[_]: Align: Functor](fi: F[Decimal], fs: F[Roman]): F[String] =
  import cats.syntax.align.* // <- HERE

programaker

import scala.util.Try

def compute(n: Int): Int =
  val res = n * 10
  println(s">>> computing $n -> $res")
  res

val n = 4
val nth = 1

programaker

import cats.effect.std.{Console, Random}
import cats.effect.{IO, Sync}

import scala.util.{Random => RandomStd}

/*
* Std lib has added `tap` and `pipe` functions for all types.
* With `tap` we can use a function to inspect the value without changing it.
* `pipe` is the equivalent of `|>` from F# or Elixir; it sends the value to a function.
* */

programaker

/*
* The good practices say we shouldn't use the same type for everything (domain, json, persistence, ...), but
* most of the time those types are very similar - if not exactly identical - creating a lot of duplication.
*
* Inheritance to the rescue? Nah... not very FP and even the OOP folks are aware that we should
* prefer composition over it. But composition has it's own challenges (Law of Demeter for instance).
*
* Let's see how the new `Export Clauses` in Scala 3 can help with that:
* https://docs.scala-lang.org/scala3/reference/other-new-features/export.html
* */

programaker

import cats.syntax.functor._

// Some types
trait A
trait B
trait C

// Some functions
val f: A => B = ???
val g: B => C = ???

programaker

import cats.effect.IO
import cats.syntax.foldable._
import cats.syntax.applicative._
import cats.syntax.applicativeError._
import cats.{ApplicativeThrow, Monad}

import scala.util.Try

// Stores type aliases for effects that have more then one type parameter
object Fs {