loderunner

ld – Wading through Mac OS X linker hell

Intro

Friend: I tried looking at static linking in Mac OS X and it seems nearly impossible. Take a look at this http://stackoverflow.com/a/3801032

Me: I have no idea what that -static flag does, but I'm pretty sure that's not how you link to a library. Let me RTFM a bit.

Minutes later...

Avaq

const I  = x => x
const K  = x => y => x
const A  = f => x => f (x)
const T  = x => f => f (x)
const W  = f => x => f (x) (x)
const C  = f => y => x => f (x) (y)
const B  = f => g => x => f (g (x))
const S  = f => g => x => f (x) (g (x))
const S_ = f => g => x => f (g (x)) (x)
const S2 = f => g => h => x => f (g (x)) (h (x))

gigamonkey

Write a program that does what it’s supposed to do
Write idiomatic code
Debug a program that you wrote
Debug a program someone else wrote
Debug the interaction between a system you wrote and one you didn’t
File a good bug report
Modify a program you didn’t write
Test a program you wrote
Test a program you didn’t write
Learn a new programming language

natefaubion

arg |> foo[0].bar(42)
    |> baz("hello", "there")
    |> quux.foo().bar()
    |> new Foo()
// Expands to:
//     new Foo(quux.foo().bar(baz('hello', 'there', foo[0].bar(42, arg))));

arg |> foo() |> bar
// SyntaxError: [|>] Expected function call
// 31: arg |> foo() |> bar

gregsh

Here are my attempts to script an IntelliJ-based IDE using javax.script.* API (ex-JSR-223).

The list of available scripting languages and engines:

1. Groovy - built-in, via Groovy jars and <app>/lib/groovy-jsr223-xxx.jar
2. JavaScript (Nashorn) - built-in, via Java Runtime <app>/jbr/... (deprecated and will be removed soon)
3. JavaScript (GraalJS) - https://plugins.jetbrains.com/plugin/12548-intellij-scripting-javascript
4. JPython - https://plugins.jetbrains.com/plugin/12471-intellij-scripting-python
5. JRuby - https://plugins.jetbrains.com/plugin/12549-intellij-scripting-ruby
6. Clojure - https://plugins.jetbrains.com/plugin/12469-intellij-scripting-clojure

odersky

package scalax.collection
import scala.collection.mutable.ListBuffer

/** FoldTransformers and the views based on them are a Scala
 *  adaptation, and to some degree an extension, of Rich Hickey's
 *  transducers for Clojure. They show that the concepts can be
 *  implemented in a type-safe way, and that the implementation is
 *  quite beautiful.
 */
object FoldingViews {

kachayev

Channels Are Not Enough

... or Why Pipelining Is Not That Easy

Golang Concurrency Patterns for brave and smart.

By @kachayev

Intro

alloy

The easiest way to start using the LLVM C++ API by example is to have LLVM generate the API usage for a given code sample. In this example it will emit the code required to rebuild the test.c sample by using LLVM:

$ clang -c -emit-llvm test.c -o test.ll
$ llc -march=cpp test.ll -o test.cpp

mxswd

// this is a playground
protocol Nat {
  class func construct() -> Self
  class func value() -> Int
}

struct Z : Nat {
  static func construct() -> Z {
    return Z()
  }

staltz

The introduction to Reactive Programming you've been missing

(by @andrestaltz)

---

This tutorial as a series of videos

If you prefer to watch video tutorials with live-coding, then check out this series I recorded with the same contents as in this article: Egghead.io - Introduction to Reactive Programming.

---