dqgorelick

SuperDirt.start // start server

Server.killAll // kill server

Quarks.gui // open samples folder

// set inputs & outputs // you will need to kill the server and restart when changing the input / output

// list all devices:

interstar

# Create Chords in Sonic Pi, to send via MIDI to your other DAW or synth
# See https://www.youtube.com/watch?v=qd8SEL_rTNw

define :chordSeq do | tonic, mode, degs |
  majorKeyTriads = [:M,:m,:m,:M,:M,:m,:dim]
  minorKeyTriads = [:m,:dim,:M,:m,:m,:M,:M]
  majorKey7s = [:M7,:m7,:m7,:M7,:dom7,:m7,:halfdiminished]
  minorKey7s = [:m7,:halfdiminished,:M7,:m7,:m7,:M7,:dom7]
  
  cs = []

l1ahim

# API server: nodes should be able to reach k3s server tcp port 6443
# flannel vxlan: udp port 8472 for nodes to communicate (server and agents)
# metrics server: it collects resource metrics from kubelets and exposes them in k8s api server through metrics api. tcp port 10250
# https://rancher.com/docs/k3s/latest/en/installation/install-options/

# run the installation script
curl -sfL https://get.k3s.io | sh -

# create k3s group and add user to avoid using always sudo
sudo groupadd k3s

unfo

A few tips for OSCP

1. Doing all of the exercises is important since you will discover low-hanging fruit from the labs based on the recon you do with the different tools in the exercises.
2. Be wary of doing full /24 range port scans, especially for anything more than a few TCP ports. The machines might be in all sorts of broken states left by students etc.
3. When starting to recon a specific machine:

• Revert
• Port scan
• Try to identify services

Those steps in that order are important. You want a fresh state for the machine and you want to do just simple port scanning first because doing nmap's service scanning or nse scripts might send payloads that actually crash services. So be careful.

unfo

How to pass the OSCP

1. Recon
2. Find vuln
3. Exploit
4. Document it

Recon

Unicornscans in cli, nmap in msfconsole to help store loot in database.

queertypes

module API.Logging (
  -- * Initialize
  mkLog,

  -- * Context, Types
  Context(..),
  Method(..),
  Log,

  -- * Logging

queertypes

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE TypeOperators #-}
-- Findings: almost everything could be inferred

bkaradzic

Orthodox C++

What is Orthodox C++?

Orthodox C++ (sometimes referred as C+) is minimal subset of C++ that improves C, but avoids all unnecessary things from so called Modern C++. It's exactly opposite of what Modern C++ suppose to be.

Why not Modern C++?

ucarion

/Users/ulyssecarion/rust/sparsile/src/lib.rs:7:9: 13:10 error: cannot infer an appropriate lifetime for lifetime parameter `'a` due to conflicting requirements
/Users/ulyssecarion/rust/sparsile/src/lib.rs:7         State {
/Users/ulyssecarion/rust/sparsile/src/lib.rs:8             runState: |firstState| {
/Users/ulyssecarion/rust/sparsile/src/lib.rs:9                 let (result, nextState) = (self.runState)(firstState);
/Users/ulyssecarion/rust/sparsile/src/lib.rs:10
/Users/ulyssecarion/rust/sparsile/src/lib.rs:11                 (f(result).runState)(nextState)
/Users/ulyssecarion/rust/sparsile/src/lib.rs:12             }
                                                ...
/Users/ulyssecarion/rust/sparsile/src/lib.rs:6:65: 14:6 note: first, the lifetime cannot outlive the block at 6:64...
/Users/ulyssecarion/rust/sparsile/src/lib.rs:6     fn and_then<B>(&self, f: |A| -> State<S, B>) -> State<S, B> {

Jxck

type errWriter struct {
	w io.Writer
	err error
}

func (e *errWriter) Write(p []byte) {
	if e.err != nil {
		return
	}
	_, e.err = e.w.Write(p)