{{ message }}

Instantly share code, notes, and snippets.

# Albert Yang albertnetymk

• Uppsala, Sweden
Last active Mar 8, 2018
View hello.cc
 // https://developers.google.com/edu/c++/getting-started #include #include using namespace std; static int a, b, c; int new_sum(int sum, bool& terminated) {
Created Dec 9, 2017
View problem.md

Find the max and min of `sum` of all permutations of [1..9] satisfying the following condition:

``````    sum
== a[1] + a[2] + a[3]
== a[3] + a[4] + a[5]
== a[5] + a[6] + a[7]
== a[7] + a[8]
where sum = a[0] + a[1]
``````
Created Sep 4, 2016
View box.hs
 {-# LANGUAGE NamedFieldPuns #-} import Data.List ((\\)) type Grid = [[Char]] third_d :: Int -> Int -> Int third_d x y = head \$ [1..3] \\ [x,y] data Op = L | R | U | D deriving (Show) data State = State {
Last active Nov 28, 2016
View lab3.md

## 0. Warmup

### Hoogle

Hoogle is the search engine for Haskell functions. It supports searching by function names and types.

For example, you plan to use `parMap`, but forget its type. You could just type `parMap` in Hoogle, and the search result would look like:

Last active Nov 12, 2015
View hello.stp
 global gc_major global gc_minor global gc_major_count global gc_minor_count global stat global count_stat probe process("/home/albert/github/otp/bin/x86_64-unknown-linux-gnu/beam.smp").mark("gc_major__start") { gc_major[user_string(\$arg1)] = gettimeofday_ms() - gc_major[user_string(\$arg1)]
Last active Nov 21, 2017
View lab2.md

# Racket lab

## 0 Background

### DrRacket

#### General

DrRacket provides rudimentary features for Racket programming, you could experiment them by launch DrRacket directly. Some particularly interesting/useful ones are highlighted here:

Created Oct 22, 2015
View cache.c
 #include #include #include // copied from http://rosettacode.org/wiki/Sorting_algorithms/Insertion_sort#C void insertion_sort (int *a, int n) { int i, j, t; for (i = 1; i < n; i++) { t = a[i]; for (j = i; j > 0 && t < a[j - 1]; j--) {
Last active Sep 10, 2015
View STM.md

## How STM interacts with locks in kappa

I would firstly assume `sync` block has the same semantics of `pthread_mutex_lock`. When the execution outside of transactions reaches `sync` block, it would gain exclusive access to this critical region, and all other executions, either inside or outside transactions, are blocked if they try to enter the critical region.

When the execution inside of transactions reaches `sync` block, it would gain non-exclusive access to this critical region, which could be obtained by any other executions inside transactions, but executions outside transactions would be blocked.

In other words, the mutex lock inside the transactions becomes a reader lock, and mutex lock outside the transactions becomes a writer lock.

## Software transactional memory

Last active Aug 29, 2015
View sfm15.md

class: center, middle

# Synchronize with Asynchronous Computation

Albert Mingkun Yang

# Block or Continuation, that's the question

• Block: Easy to read, but waste CPU cycles
Last active Aug 29, 2015
View block.java
 import java.util.*; import java.util.concurrent.*; public class block { static ForkJoinPool pool; static Server s; static Client c1, c2; static volatile int x = 0; static class Client extends RecursiveAction { @Override