eulerfx

/// Operations on Berkley sockets.
[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module Socket =

  /// Executes an async socket operation.
  let exec (alloc:unit -> SocketAsyncEventArgs, free:SocketAsyncEventArgs -> unit) (config:SocketAsyncEventArgs -> unit) (op:SocketAsyncEventArgs -> bool) (map:SocketAsyncEventArgs -> 'a) =
    Async.FromContinuations <| fun (ok, error, _) ->

      let args = alloc ()

mavnn

module Logary.Obnoxious

open Logary
open Logary.Configuration
open Logary.Targets
open Hopac
open Hopac.Infixes
open Hopac.Job.Global
open Hopac.Extensions.Async
open Hopac.Extensions.Async.Global

MichalZalecki

// Import all

import Rx from "rxjs/Rx";

Rx.Observable
  .interval(200)
  .take(9)
  .map(x => x + "!!!")
  .bufferCount(2)
  .subscribe(::console.log);

gtallen1187

"Scar Tissues Make Relationships Wear Out"

04/26/2103. From a lecture by Professor John Ousterhout at Stanford, class CS142.

This is my most touchy-feely thought for the weekend. Here’s the basic idea: It’s really hard to build relationships that last for a long time. If you haven’t discovered this, you will discover this sooner or later. And it's hard both for personal relationships and for business relationships. And to me, it's pretty amazing that two people can stay married for 25 years without killing each other.

[Laughter]

> But honestly, most professional relationships don't last anywhere near that long. The best bands always seem to break up after 2 or 3 years. And business partnerships fall apart, and there's all these problems in these relationships that just don't last. So, why is that? Well, in my view, it’s relationships don't fail because there some single catastrophic event to destroy them, although often there is a single catastrophic event around the the end of the relation

cloudRoutine

open System.Collections.Generic
open Microsoft.FSharp.Collections


[<RequireQualifiedAccess>]
module Folds =

    // These are the fast implementations we actually want to use

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.

---

eulerfx

type Service<'Input, 'Output> = 'Input -> Async<'Output>

/// A filter is an aspect in the AOP sense.
type Filter<'Input, 'InputInner, 'OutputInner, 'Output> = 'Input-> Service<'InputInner, 'OutputInner> -> Async<'Output>

type Filter<'Input, 'Output> = 'Input-> Service<'Input, 'Output> -> Async<'Output>

type Continuation<'a,'r> = ('a  -> 'r) -> 'r

module Continuation =     

paulp

# bash function
defcomp () {
  local name="$1" && shift
  local functionName="$( echo "${name}_completion" | tr - _ )"
  source <(cat <<EOM
$functionName () {
  local cur
  _get_comp_words_by_ref -n =: cur
  COMPREPLY=( \$(compgen -W "\$( $@ )" -- "\$cur") )
}

debasishg

General Background and Overview

1. Probabilistic Data Structures for Web Analytics and Data Mining : A great overview of the space of probabilistic data structures and how they are used in approximation algorithm implementation.
2. Models and Issues in Data Stream Systems
3. Philippe Flajolet’s contribution to streaming algorithms : A presentation by Jérémie Lumbroso that visits some of the hostorical perspectives and how it all began with Flajolet
4. Approximate Frequency Counts over Data Streams by Gurmeet Singh Manku & Rajeev Motwani : One of the early papers on the subject.
5. [Methods for Finding Frequent Items in Data Streams](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.187.9800&rep=rep1&t

valentt

# download latest libevent2 and tmux sources, and extract them somewhere
#
# at the time of writing:
# https://github.com/downloads/libevent/libevent/libevent-2.0.21-stable.tar.gz
# http://sourceforge.net/projects/tmux/files/latest/download?source=files
# 

# don't compile tools as root, just don't do it.

# install deps