frekw

def comment do
    gen all id <- positive_integer(),
            author <- string(:alphanumeric, max_length: 64),
            body <- string(:alphanumeric) do
      %{id: id,
        author: author,
        body: body}
    end
  end

frekw

defmodule Forma do
  # defmacro __using__([]) do
  #   quote do
  #     import Forma, only: [forma: 2]
  #   end
  # end

  # defmacro forma(name, module) do
  #   module = Macro.expand(module, __CALLER__)
  #   transform = Forma.compile_module(module)

frekw

type timerID;
[@bs.val] external setInterval: (unit => unit, int) => timerID = "setInterval";
[@bs.val] external clearInterval: timerID => unit = "clearInterval";

module Counter = {
    let component = ReasonReact.component("Counter");
    let make = (~initial = 0, _children) => {
        ...component,
        render: _self => {
            let (count, setCount) = ReactHooks.useState(initial);

frekw

# vi-like navigation setw -g mode-keys vi
# mouse control for panes
set -g mouse on

# don't rename windows automagically
set-option -g allow-rename off

# start windows numbering at 1 and rename on window close
setw -g pane-base-index 1
set -g base-index 1

frekw

defmodule Producer do
  require Logger
  use GenStage

  def start_link([]) do
    Logger.info("starting producer")
    GenStage.start_link(__MODULE__, :ok, name: __MODULE__)
  end

  def init(:ok) do

frekw

function useAsync() {
  const [fn, setFn] = useState(null);
  const [state, setState] = useState({
    loading: false,
    data: null,
    error: null
  });
  const lastCallId = useRef(0);

  useEffect(() => {

frekw

package example

import zio._
import zio.console
import zio.random._
import zio.duration._
import zio.clock
import scala.concurrent.Future

// What _is_ ZIO?

frekw

package zio_grpc.examples.helloworld

import io.grpc.Status
import scalapb.zio_grpc.ServerMain
import scalapb.zio_grpc.ServiceList
import scalapb.zio_grpc.{RequestContext, ZTransform}
import zio._
import zio.console._
import zio.stream._

frekw

package gql.remoteschema

import zio._
import zio.query._
import caliban._
import caliban.schema._
import caliban.introspection.adt._
import caliban.execution.Field

import gql.remoteschema.json._

frekw

def accessLogger[R, E](
      next: Http[R, E, Request, HttpResponse[R, E]]
  ): HttpApp[R with clock.Clock with Logging, E] = {
    Http.flatten {
      Http.fromEffectFunction[Request] { req =>
        val path = req.url.path
        val method = req.method

        clock.instant.flatMap(start => {
          val logSuccess = (resp: HttpResponse[R, E]) => {