Skip to content

Instantly share code, notes, and snippets.

@ssrihari
ssrihari / clojure-learning-list.md
Last active June 4, 2024 08:50
An opinionated list of excellent Clojure learning materials

An opinionated list of excellent Clojure learning materials

These resources (articles, books, and videos) are useful when you're starting to learn the language, or when you're learning a specific part of the language. This an opinionated list, no doubt. I've compiled this list from writing and teaching Clojure over the last 10 years.

  • 🔴 Mandatory (for both beginners and intermediates)
  • 🟩 For beginners
  • 🟨 For intermediates

Table of contents

  1. Getting into the language
@joelonsql
joelonsql / PostgreSQL-EXTENSIONs.md
Last active June 11, 2024 14:52
1000+ PostgreSQL EXTENSIONs

🗺🐘 1000+ PostgreSQL EXTENSIONs

This is a list of URLs to PostgreSQL EXTENSION repos, listed in alphabetical order of parent repo, with active forks listed under each parent.

⭐️ >= 10 stars
⭐️⭐️ >= 100 stars
⭐️⭐️⭐️ >= 1000 stars
Numbers of stars might not be up-to-date.

@dvanhorn
dvanhorn / advent-03.rkt
Created December 3, 2020 18:55
Advent of Code, Day 3, Part II
#lang racket
(define in "...")
(define (string-ref-mod xs i)
(string-ref xs (modulo i (string-length xs))))
(define lines (call-with-input-string in port->lines))
(define (c δx δy)
(for/sum ([x (in-range 0 +inf.0 δx)]
@kimagure44
kimagure44 / Advent of code (2020) - CODE 3 - 1
Created December 3, 2020 07:57
Advent of code (2020) - CODE 3 - 1
(async () => {
const result = [];
const entries = (await(await fetch('https://adventofcode.com/2020/day/3/input')).text()).split('\n').filter(item => item || false);
const startTime = performance.now();
const rowLen = entries[0].length;
const incX = 3;
let movRight = 0;
let totalTree = 0;
entries.forEach((row, index) => {
if (movRight >= rowLen) {
@mfikes
mfikes / keys-vals.md
Last active November 23, 2020 13:27

The following works in Clojure:

(keys (filter (comp odd? val) {:a 1 :b 2 :c 3}))

The docstrings for keys and vals don't indicate that you can do this. Is this accidential or intentional?

I vaguely recall Alex Miller indicating at some point that this capability was deemed useful and is intentionally allowed. Yes, this is an appeal to authority, but nevertheless, it makes a fairly convincing argument.

@ryan-haskell
ryan-haskell / Api.elm
Created July 12, 2020 05:23
Used in the "Using APIs" section of in the elm-spa guide
-- src/Api.elm
module Api exposing (Data(..), expectJson)
import Http
import Json.Decode as Json
type Data value
= NotAsked
| Loading
@wokalski
wokalski / Readme.md
Last active February 21, 2020 12:44
BuckleScript friendly `vim` + official ocaml-lsp setup for Reason/OCaml

BuckleScript friendly vim + official ocaml-lsp setup for Reason/OCaml

Prerequisite: Install esy 0.6.0.

Steps

  1. Check esy version (it has to be >0.6.0)
  2. Create esy.json with the following contents next to package.json:
@yogthos
yogthos / clojure-beginner.md
Last active June 12, 2024 10:42
Clojure beginner resources

Introductory resources

@swlaschin
swlaschin / fsharpjobs.md
Last active June 10, 2024 04:19
My suggestions on how to look for F# jobs

How to find F# jobs

People often ask me how to find F# jobs. I don't have any special connections to companies using F#, and I don't have any special tricks either. I wish I did!

So, given that, here's my take on F# jobs.

Job hunting

For job hunting my suggestions are:

@sebmarkbage
sebmarkbage / WhyReact.md
Created September 4, 2019 20:33
Why is React doing this?

I heard some points of criticism to how React deals with reactivity and it's focus on "purity". It's interesting because there are really two approaches evolving. There's a mutable + change tracking approach and there's an immutability + referential equality testing approach. It's difficult to mix and match them when you build new features on top. So that's why React has been pushing a bit harder on immutability lately to be able to build on top of it. Both have various tradeoffs but others are doing good research in other areas, so we've decided to focus on this direction and see where it leads us.

I did want to address a few points that I didn't see get enough consideration around the tradeoffs. So here's a small brain dump.

"Compiled output results in smaller apps" - E.g. Svelte apps start smaller but the compiler output is 3-4x larger per component than the equivalent VDOM approach. This is mostly due to the code that is usually shared in the VDOM "VM" needs to be inlined into each component. The tr