wtask

package errcode

import (
	"fmt"
)

// Fault type is implementation of standard error interface with minimal details like error scope and error code
// and the error scope is a "namespace" of error code used.
// Also the Fault type contain Cause field to save original (underlying) error and to support error-wrapping chains.
//

andersevenrud

True Color (24-bit) and italics with alacritty + tmux + vim (neovim)

This should make True Color (24-bit) and italics work in your tmux session and vim/neovim when using Alacritty (and should be compatible with any other terminal emulator, including Kitty).

Testing colors

Running this script should look the same in tmux as without.

curl -s https://gist.githubusercontent.com/lifepillar/09a44b8cf0f9397465614e622979107f/raw/24-bit-color.sh >24-bit-color.sh

straker

Basic Snake HTML and JavaScript Game

Snake is a fun game to make as it doesn't require a lot of code (less than 100 lines with all comments removed). This is a basic implementation of the snake game, but it's missing a few things intentionally and they're left as further exploration for the reader.

Further Exploration

• Score
• When the snake eats an apple, the score should increase by one. Use context.fillText() to display the score to the screen

coreyhaines

module Editable exposing (..)


type Editable ofType
    = NotEditing { value : ofType }
    | Editing { originalValue : ofType, buffer : ofType }


value : Editable ofType -> ofType
value editable =

marianogappa

/*
This snippet is an example of backpressure implementation in Go.
It doesn't run in Go Playground, because it starts an HTTP Server.

The example starts an HTTP server and sends multiple requests to it. The server starts denying
requests by replying an "X" (i.e. a 502) when its buffered channel reaches capacity.

This is not the same as rate-limiting; you might be interested in https://github.com/juju/ratelimit
or https://godoc.org/golang.org/x/time/rate.

srdjan

100+ different js counter apps...

coreyhaines

module Flow exposing (Flow(..), map, withDefault, mapDefault, view, update)

import Html


type Flow state
    = NotRunning
    | Running state

harpocrates

Control.Arrow
=============
  "compose/arr"   forall f g .
                  (arr f) . (arr g) = arr (f . g)
  "first/arr"     forall f .
                  first (arr f) = arr (first f)
  "second/arr"    forall f .
                  second (arr f) = arr (second f)
  "product/arr"   forall f g .
                  arr f *** arr g = arr (f *** g)

wolfeidau

package main

// The aim of this example is to illustrate backpressure using golang channels and go routines.
//
// This is the basis for a simple data processing service which could either be reading from
// some internal queue or a socket of some sort.

import (
	"fmt"
	"math/rand"

vasanthk

System Design Cheatsheet

Picking the right architecture = Picking the right battles + Managing trade-offs

Basic Steps

1. Clarify and agree on the scope of the system

• User cases (description of sequences of events that, taken together, lead to a system doing something useful)
  • Who is going to use it?
  • How are they going to use it?