Scala as bleeding-edge Java

Concision

Scala

• encourages programmers to express themselves cleanly and concisely with very little boilerplate.

• successfully blends multiple programming-language paradigms (functional, object-oriented), enabling whichever style best models a particular problem or domain.

• combines flexible syntax with extraordinary type safety, enabling construction of "dialects" that function as domain-specific languages.

Concision — Primes in Java

public final class Primes {
  public static boolean isPrime(int n) {
    var isPrime = true;
    var max = (int) Math.floor(Math.sqrt(n));
    for (int i = 2; i <= max; ++i) {
      if (n % i == 0) {
        isPrime = false;
        break;
      }
    }
    return isPrime;
  }
}

Concision — Primes in Scala

def isPrime( n : Int ) =
  !(2 to math.floor(math.sqrt(n)).toInt).exists( n % _ == 0 )

or, perhaps more readably...

def isPrime( n : Int ) =
  val max = math.floor(math.sqrt(n)).toInt
  !(2 to max).exists( n % _ == 0 )

I am using Scala 3 syntax!

Concision — Primes in Java, functional style

import java.util.stream.IntStream;

public final class Primes {
  public static boolean isPrime(int n) {
    var max = (int) Math.floor(Math.sqrt(n));
    return !IntStream.rangeClosed( 2, max )
                     .anyMatch(check -> n % check == 0 );
  }
}

Pretty close!

Safety

def sendmail(to: String, subject: String, text: String)  = ???

Yuck. 🤮

Enforce everything you know at compile-time!

def sendmail(to: Email, subject: String, text: String)  = ???

The ??? function is a wonderful convenience!

Abstraction

e.g. "tagless final" style — very optional! love it or hate it!

// from Practical FP in Scala, 2nd Ed, by Gabriel Volpe (2021)
final case class Checkout[F[_]: Background: Logger: MonadThrow: Retry](
    payments: PaymentClient[F],
    cart:     ShoppingCart[F],
    orders:   Orders[F],
    policy:   RetryPolicy[F]
){
  def process(userId: UserId, card: Card): F[OrderId] =
    cart.get(userId).flatMap {
      case CartTotal(items, total)  =>
        for {
          its <- ensureNonEmpty(items)
          pid <- processPayment(Payment(userId, total, card))
          oid <- createOrder(userId, pid, its, total)
          _   <- cart.delete(userId).attempt.void
        } yield oid
     }
  def processPayment(in: Payment): F[PaymentId] =
    Retry[F] // calls no-arg apply methods of Retry, finds implicit instance
      .retry(policy, Retriable.Payments)(payments.process(in))
      .adaptError {
        case e => PaymentError( Option(e.getMessage).getOrElse("Unknown") )
      }
  // ...
}

Hyperscale

The Scala ecosystem includes libraries for building concurrent, resilient, incredibly scalable services based on transformable "functional effects".

• ZIO
• Cats effects / FS2

See also Tapir, an infrastructure agnostic endpont definition library.

These are libraries are challenging. End up here, but don't start your Scala journey with these tools, unless you are working with a team to mentor you.

Simplicity

• Scala's best kept secret is how beautifully you can accomplish simple things very simply, while getting all the benefits of strong type safety.

• Scala's built-in collections library is a superpower.

scala-cli

• supports Java code as well and easily as Scala code!

  • On the Java side, jbang is the closest competition, but scala-cli is in some respects easier to use, more "batteries included"
  • and of course, scala-cli supports Scala too

• Consider prototyping your Java projects with scala-cli

  • https://scala-cli.virtuslab.org/
  • maybe mix in a bit of Scala!