Skip to content

Instantly share code, notes, and snippets.

View YBogomolov's full-sized avatar

Yuriy Bogomolov YBogomolov

184 followers · 35 following
View GitHub Profile
@rgreenjr
rgreenjr / postgres_queries_and_commands.sql
Last active June 1, 2024 14:11
Useful PostgreSQL Queries and Commands
-- show running queries (pre 9.2)
SELECT procpid, age(clock_timestamp(), query_start), usename, current_query
FROM pg_stat_activity
WHERE current_query != '<IDLE>' AND current_query NOT ILIKE '%pg_stat_activity%'
ORDER BY query_start desc;
-- show running queries (9.2)
SELECT pid, age(clock_timestamp(), query_start), usename, query
FROM pg_stat_activity
WHERE query != '<IDLE>' AND query NOT ILIKE '%pg_stat_activity%'
@kuitos
kuitos / range-slider.html
Last active September 25, 2017 22:00
range slider base on angular-material slider
<!--
Created by Kuitos on 2015/03/06 10:15 AM.
Email: kuitos.lau@gmail.com
author: EdwardCTaylor
author: Kuitos
Licence: MIT
-->
<!DOCTYPE html>
<html>
<head>
@jdegoes
jdegoes / Applied-FP-with-Scala.md
Last active May 9, 2024 08:27

Applied Functional Programming with Scala - Notes

Copyright © 2016-2018 Fantasyland Institute of Learning. All rights reserved.

1. Mastering Functions

A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.

val square : Int => Int = x => x * x
@hediet
hediet / main.md
Last active March 11, 2024 15:05
Proof that TypeScript's Type System is Turing Complete 
type StringBool = "true"|"false";


interface AnyNumber { prev?: any, isZero: StringBool };
interface PositiveNumber { prev: any, isZero: "false" };

type IsZero<TNumber extends AnyNumber> = TNumber["isZero"];
type Next<TNumber extends AnyNumber> = { prev: TNumber, isZero: "false" };
type Prev<TNumber extends PositiveNumber> = TNumber["prev"];
@ismyrnow
ismyrnow / mac-clear-icon-cache.sh
Created May 5, 2017 19:28
Clear the icon cache on a Mac when you start seeing generic icons in Finder or the Dock
sudo rm -rfv /Library/Caches/com.apple.iconservices.store; sudo find /private/var/folders/ \( -name com.apple.dock.iconcache -or -name com.apple.iconservices \) -exec rm -rfv {} \; ; sleep 3;sudo touch /Applications/* ; killall Dock; killall Finder
@d1egoaz
d1egoaz / learning_scala.org
Last active November 5, 2023 21:39
@aroslov
aroslov / LazyParameter.ts
Last active June 3, 2019 10:46
Lazy Parameter from AWS SSM
import { getParameterFromSsm } from 'aws-ssm.sdk'
function getParameterValue(name: string, defaultValue: string) {
return process.env[name] || getParameterFromSsm(name, defaultValue);
}
export class LazyParameter extends LazyValue<string> {
constructor(name: string, defaultValue?: string) {
super(async () => {
return getParameterValue(name, defaultValue);
@maksbotan
maksbotan / generic-validation.md
Last active July 5, 2020 20:34
Generic validation of nested data

Generic validation of nested data

TLDR

This technique helps validate arbitrary conditions in deeply nested structures without writing additional code — with the help of Haskell Generics.

It boils down to this pattern:




  


  




    


          
    

      

        
        

          

              @lexi-lambda
          

          

            
                lexi-lambda
                / continuations-and-reduction-semantics.md
            
            

              Last active
              March 31, 2024 12:13
            

          

        

      

        

  

      

    
Monads and delimited control are very closely related, so it isn’t too hard to understand them in terms of one another. From a monadic point of view, the big idea is that if you have the computation m >>= f, then f is m’s continuation. It’s the function that is called with m’s result to continue execution after m returns.


If you have a long chain of binds, the continuation is just the composition of all of them. So, for example, if you have


m >>= f >>= g >>= h


then the continuation of m is f >=> g >=> h. Likewise, the continuation of m >>= f is g >=> h.



  


  




    


          
    

      

        
        

          

              @gcanti
          

          

            
                gcanti
                / GADT.ts
            
            

              Last active
              September 23, 2022 10:55
            

              
                Approximating GADTs in TypeScript
              
          

        

      

        

  

    
    


        



  


  

        

          
          // Adapted from http://code.slipthrough.net/2016/08/10/approximating-gadts-in-purescript/
        

        

          
          

        

        

          
          import { Kind, URIS } from 'fp-ts/lib/HKT'
        

        

          
          import { URI } from 'fp-ts/lib/Identity'
        

        

          
          import { identity } from 'fp-ts/lib/function'
        

        

          
          

        

        

          
          // ------------------------------------------
        

        

          
          // Leibniz
        

        

          
          // ------------------------------------------