kubukoz

//> using scala 3.7
//> using dep org.http4s::http4s-ember-server:0.23.30
//> using dep org.http4s::http4s-dsl:0.23.30
//> using dep org.http4s::http4s-scalatags::0.25.2
//> using option -Wunused:all
import scalatags.Text.all.*
import cats.effect.*
import fs2.Stream
import org.http4s.*
import org.http4s.dsl.io.*

debasishg

Performance Engineering, Hardware and cache awareness with algorithm and data structures

1. Parallel Computing Course - Stanford CS149, Fall 2023
2. Performance-Aware Programming Series by Casey Muratori
3. Algorithms for Modern Hardware
4. Computer Systems: A Programmer's Perspective, 3/E - by Randal E. Bryant and David R. O'Hallaron, Carnegie Mellon University
5. Performance Engineering Of Software Systems - am MITOCW course
6. Parallel Programming 2020 by NHR@FAU
7. Cpu Caches and Why You Care - by Scott Meyers
8. [Optimizing a ring buffer for throughput](https://rig

dacr

// summary : An API to rule them all - to define or customize new API at runtime
// keywords : scala, zio, tapir, http, zhttp, stateful, state, @testable, @exclusive
// publish : gist
// authors : David Crosson
// license : Apache NON-AI License Version 2.0 (https://raw.githubusercontent.com/non-ai-licenses/non-ai-licenses/main/NON-AI-APACHE2)
// id : dbccfc26-c532-4aa9-b3cd-eb13cbaa5370
// created-on : 2023-12-08T18:45:32+01:00
// managed-by : https://github.com/dacr/code-examples-manager
// run-with : scala-cli $file
// test-with : curl -L http://127.0.0.1:8080/hello/david

carlosedp

This is a Scala script to check for Mill build plugin and scala-cli lib updates. The plugin requires scala-cli.

Run directly from the gist with:

scala-cli https://gist.github.com/carlosedp/c3ea2814ac5392051a562e95c1298239/raw/checkdeps.sc

Or download the script, make it executable and run as:

djspiewak

What follows are some of my (very) rough thoughts on what we can and should do with respect to CPS transformation in Scala at the language level. I'll try to start with some motivation behind my thinking, as well as some rambling observations on the nature of the problem space, but don't expect too much coherence here. :-)

The Problem

Async programming is hard.

Okay let's actually be more specific than that. High-performance I/O is hard. Signal multiplexing is a powerful technique for achieving high(er) performance I/O, particularly network I/O, but the tradeoff is that, in order to utilize it, the user-space programming model must allow for suspension and resumption of sequential continuations (often called "fibers" or "coroutines"). Achieving this type of programming model without significant tradeoffs in usability is what is exceptionally hard.

If that wasn't bad enough though, these problems are inextricably conflated with another set of problem spaces which are, themselves, very difficult. In

julien-truffaut

We recently started the development of the next major version of Monocle, Monocle 3.x. In this post, I would like to explain our objectives and discuss some of the changes we intend to make.

Monocle 3.x will be a complete rewrite. It doesn't mean we will change everything, but we will question every aspect of the library: optics encoding, API, names, dependencies, etc. We defined the following objectives to help us make trade-offs in the new design:

1. User-friendly interface. A user should be able to perform the most common actions without requiring in-depth knowledge of optics.
2. Correctness. Optics follow certain essential principles. Those rules may not be intuitive, but without them, optics would not be a useful abstraction. The API should make it easy to follow those principles and avoid any undesired behaviours.
3. Focus on Scala 3. We should design the API and include features such as they are suitable for Scala 3.
4. Performance. Optics are slower than handwritten equivalent code

dacr

David's programming examples knowledge base

• Generated by code-examples-manager release 2.4.9-SNAPSHOT
• 659 published examples

akka-pekko

• akka-actors-hello-world.sc : Simple akka hello world example
• akka-capitalize-and-print.sc : dump capitalized string coming from stdin using streams
• akka-http-client-json-stream.sc : Fully asynchronous http client call with json streamed response using akka-http will work in all cases, even with chunked responses !
• akka-http-client-json-with-proxy.sc : Fully asynchronous http client call with json response using akka-http will work in all cases, even with chunked responses, this example add automatic http proxy support.
• [akka-http-client-json.sc](https:/

silvesthu

GPU Optimization for GameDev

Graphics Pipeline / GPU Architecture Overview

• 2011 - A trip through the Graphics Pipeline 2011
• 2013 - Performance Optimization Guidelines and the GPU Architecture behind them
• 2015 - Life of a triangle - NVIDIA's logical pipeline
• 2015 - Render Hell 2.0
• 2016 - How bad are small triangles on GPU and why?
• 2017 - GPU Performance for Game Artists
• 2019 - Understanding the anatomy of GPUs using Pokémon

abeln

Scala with Explicit Nulls

Contents

• What is This?
• New Type Hierarchy
• Unsoundness
• Equality
• Working with Null
• Java Interop

fbaierl

object Format {

  /**
    * String interpolation [[java.text.MessageFormat]] style:
    * {{{
    *   format("{1} {0}", "world", "hello") // result: "hello world"
    *   format("{0} + {1} = {2}", 1, 2, "three") // result: "1 + 2 = three"
    *   format("{0} + {0} = {0}", 0) // throws MissingFormatArgumentException
    * }}}
    * @return