Sur la toile

You have to earn the right to be heard about what you do and what you want to accomplish. People really don’t care about what you do until they know that you care about what they do. Secret #1: Assume the burden of other people’s discomfort Secret #2: Give and expect nothing in return Secret #3: Be proud of who you are Secret #4: Compliment early and often Secret #5: Look for common ground immediately Secret #6: Tap your sphere of influence cautiously Secret #7: Do not keep your personal and professional lives separate Secret #8: Pull—never push Secret #9: Include social media into your networking Secret #10: Lose control of your marketing

If a hallway conversation stalls, ask what they're working on. Discover the project they're passionate about. @chrishouser

1. take notes in Emacs/Vim/etc.
2. meet people and go to the evening events and such to have good conversations.

@Baranosky

It helps tremendously to read up on the topics before a presentation, so that you aren't entering cold. @AustinTHaas

take notes. revisit the notes. read them again. then write about them. @darevay

My two rules: leave the laptop at hotel and introduce yourself to everyone. It opens so many doors to learning. @jackdanger

the talks will be great, but the hallway conversations are better. be aggressive about meeting people. Take advantage of the face time. @jimduey

Talk to people about the presentations during the breaks. Meeting people is the most rewarding part. @ericnormand

http://gspadmin.com/how-tos/voice-servers/how-to-install-mumble-linux/

Writing tests first forces you to think about the problem you're solving. Writing property-based tests forces you to think way harder.

http://www.youtube.com/user/DIYCloudComputing

https://github.com/pallet/pallet-vmfest

Two ways: one is to use .clj data files on the classpath and take advantage of the fact that different profiles put different resources directories on the classpath. This is the approach taken by Carica (https://github.com/sonian/carica) and works great if you have complex config with nested values.

The other approach is to use environment variables; the best tool for that is Environ: https://github.com/weavejester/environ

ASM Embedded CPU FORTH Verilog Spartan 3 FPGA C++ Raspberry Pi

• grep . *.txt
• more * | cat
• "fmt -1" (split lines into individual words)
• gnt-job list | egrep –color=always 'running|waiting'

Amazon Dynamo Paper. It has some very interesting concepts, but ultimately fails to provide a good balance of reliability, performance and cost.

Design patterns -> theorems -> Language & tool support "When I see patterns in my programs, I consider it a sign of trouble… a sign that I'm not using abstractions that aren't enough powerful" Paul Graham Consistency As Logical Monotinicity

The notion of Turing-completeness does not apply to languages such as XML, JSON, YAML and S-expressions, because they are typically used to represent structured data, not describe computation.

How anthropomorphism and analogies make concepts in computer programming harder to understand:

http://www.computer.org/portal/web/computingnow/content?g=53319&type=article&urlTitle=a-glimpse-of-the-future-of-scientific-programming&lf1=267408692c637116407312f6779968

http://eng.42go.com/pattern-matching-in-scala/ http://eng.42go.com/a-simple-time-decaying-approximate-membership-filter/

Erlang has very cheap threads now you can use concurrency as a control structure very close to object oriented programming and dynamic dispatch. what the Reactive framework is, it’s just the continuation monad … it is the observer observable is the dual of enumerable enumerator

What would I recommend learning?

• C
• Prolog
• Erlang (I'm biased)
• Smalltalk
• Javascript
• Hakell / ML /OCaml
• LISP/Scheme/Clojure

A couple of years should be enough (PER LANGUAGE).

Notice there is no quick fix here - if you want a quick fix go buy "learn PHP in ten minutes" and spend the next twenty years googling for "how do I compute the length of a string"

The crazy think is we still are extremely bad at fitting things together - still the best way of fitting things together is the unix pipe

find … | grep | uniq | sort | …

and the fundamental reason for this is that components should be separated by well-defined protocols in a universal intermediate language.

Fitting things together by message passing is the way to go - this is basis of OO programming - but done badly in most programming languages.

If ALL applications in the world were interfaced by (say) sockets + lisp S expressions and had the semantics of the protocol written down in a formal notation - then we could reuse things (more) easily.

Today there is an unhealthy concentration on language and efficiency and NOT on how things fit together and protocols - teach protocols and not languages.

And teach ALGORITHMS.

Rust is a curly-brace, block-structured expression language. It visually resembles the C language family, but differs significantly in syntactic and semantic details. Its design is oriented toward concerns of “programming in the large”, that is, of creating and maintaining boundaries – both abstract and operational – that preserve large-system integrity, availability and concurrency. It supports a mixture of imperative procedural, concurrent actor, object-oriented and pure functional styles. Rust also supports generic programming and metaprogramming, in both static and dynamic styles.

from Van Roy and Haridi's book

http://channel9.msdn.com/posts/Frank-McSherry-Introduction-to-Naiad-and-Differential-Dataflow Naiad is an investigation of data-parallel dataflow computation in the spirit of Dryad and DryadLINQ, but with a focus on incremental computation. Naiad introduces a new computational model, differential dataflow, operating over collections of differences rather than collections of records, and resulting in very efficient implementations of programming patterns that are expensive in existing systems.

var text.SelectMany(x => x.Split(' ')) .Count(y => y, (k, c) => k " : " c) .subscribe(l => {foreach (var element in l) Console.writeLine(element)})

Concurrency is a property of the algorithm that you are designing. It determines which parts of your data-processing logic are intrinsically independent (under all inputs and circumstances).

Parallelism is a property of the realization of your algorithm. This is not your source code, but the final executable or — even more abstractly — the behavior of your program when executed.

https://github.com/puniverse/pulsar

• CAS semantics : Atom
• Coordinated change inside a transaction : ref

https://groups.google.com/forum/?fromgroups=#!topic/clojure/9NhsFga4D9s

http://sebfisch.github.io/haskell-regexp/ http://matt.might.net/articles/implementation-of-regular-expression-matching-in-scheme-with-derivatives/ http://www.mpi-sws.org/~turon/re-deriv.pdf http://matt.might.net/articles/cek-machines/ http://www.cs.tufts.edu/~nr/cs257/archive/doaitse-swierstra/combinator-parsing-tutorial.pdf The parsing library for this workshop follows the implementation of the basic combinators in the above paper. http://www.brics.dk/RS/03/14/BRICS-RS-03-14.pdf The CEK machine built in this workshop is based on the derivation in the above paper, extended with printing, if statements, and binary operations.

comonad and OO Design pattern http://www.haskellforall.com/2013/02/you-could-have-invented-comonads.html http://www.haskellforall.com/2012/06/you-could-have-invented-free-monads.html

>>> from sympy import * >>> nsimplify(4.242640687119286) 3*sqrt(2)

approximate set size (in much less memory with HyperLogLog), approximate item counting (using CountMinSketch)

http://cdn.parleys.com/p/51704efce4b095cc56d8d4b5/51700fa4a360c_1366298459509.pdf

• fathomjs http://markdalgleish.com/projects/fathom/
• csss
• 5lide
• reveal.js
• slidedown http://nakajima.github.com/slidedown/#0
• impressjs (inspired by prezi.com)
• dzslides
• jmpressjs http://jmpressjs.github.io/jmpress.js/examples/automatic-layout/

http://blog.cloudfoundry.org/2012/10/11/using-the-new-scripted-javascript-editor-for-node-js-development/

http://jonisalonen.com/2013/mathematical-foundations-of-computer-integers/ http://jonisalonen.com/2013/why-we-use-2s-complement/

Exponential decay of history is a pattern that competes with ring-buffers, least-recently-used heuristics, and other techniques that represent historical information in a limited space.

http://fr.wikipedia.org/wiki/Test_A/B http://oobaloo.co.uk/multi-armed-bandit-optimisation-in-clojure John Myles White talk vimeo.com/54970619 http://www.feynmanlectures.info/exercises/Feynmans_restaurant_problem.html

Topologic Data Analysis , NBA example (Ayasdi)

algorithms for graph partitioning and clustering, constructions of expander graphs, and analysis of random walks

http://www.vedicmaths.org/Bookstores/Manual%201.pdf

The new form of trigonometry developed here is called rational trigonometry, to distinguish it from classical trigonometry, the latter involving cos θ, sin θ and the many trigonometric relations currently taught to students. An essential point of rational trigonometry is that quadrance and spread, not distance and angle, are the right concepts for metrical geometry (i.e. a geometry in which measurement is involved).

https://github.com/gigasquid/roomba-drone-friends

• but clearly large amounts of persistent messages sitting in the broker was not the main design case for AMQP in general."
• (It's contrasted with Kafka, which is "designed for holding and distributing large volumes of messages"
• longer-lived work queues are really more of a Hadoop thing, not an in-memory queue thing

Use Kafka if you have a fire hose of events (100k+/sec) you need delivered in partitioned order 'at least once' with a mix of online and batch consumers, you want to be able to re-read messages, you can deal with current limitations around node-level HA (or can use trunk code), and/or you don't mind supporting incubator-level software yourself via forums/IRC.

Use RabbitMQ if you have messages (20k+/sec) that need to be routed in complex ways to consumers, you want per-message delivery guarantees, you don't care about ordered delivery, you need HA at the cluster-node level now, and/or you need 24x7 paid support in addition to forums/IRC.

https://github.com/RabbitMQSimulator/RabbitMQSimulator http://vimeo.com/51363470

AMQP resources:

Servers: RabbitMQ (Rabbit Technologies, Erlang/OTP, MPL) - http://rabbitmq.com ZeroMQ (iMatix/FastMQ/Intel, C++, GPL3) - http://www.zeromq.org OpenAMQ (iMatix, C, GPL2) - http://openamq.org ActiveMQ (Apache Foundation, Java, apache2) - http://activemq.apache.org

Steve Vinoski explains AMQP in his column, Towards Integration http://steve.vinoski.net/pdf/IEEE-Advanced_Message_Queuing_Protocol.pdf

John O'Hara on the history of AMQP http://www.acmqueue.org/modules.php?name=Content&pa=showpage&pid=485

Dmitriy's presentation on RabbitMQ/AMQP http://somic-org.homelinux.org/blog/2008/07/31/slides-for-my-amqprabbitmq-talk/

ZeroMQ's analysis of the messaging technology market http://www.zeromq.org/whitepapers:market-analysis

Pieter Hintjens's background to AMQP http://www.openamq.org/doc:amqp-background

Barry Pederson's py-amqplib http://barryp.org/software/py-amqplib/

Ben Hood on writing an AMQP client http://hopper.squarespace.com/blog/2008/6/21/build-your-own-amqp-client.html

Dmitriy Samovskiy introduces Ruby + QPid + RabbitMQ http://somic-org.homelinux.org/blog/2008/06/24/ruby-amqp-rabbitmq-example/

Ben Hood's as3-amqp http://github.com/0x6e6562/as3-amqp http://hopper.squarespace.com/blog/2008/7/4/server-side-as3.html http://hopper.squarespace.com/blog/2008/3/24/as3-amqp-client-first-cut.html

RabbitMQ's protocol code generator http://hg.rabbitmq.com/rabbitmq-codegen/

Erlang Exchange presentation on the implementation of RabbitMQ http://skillsmatter.com/podcast/erlang/presenting-rabbitmq-an-erlang-based-implementatio-nof-amqp http://www.lshift.net/blog/2008/07/01/slides-from-our-erlang-exchange-talk

Jonathan Conway's series on RabbitMQ and using it with Ruby/Merb http://jaikoo.com/2008/3/20/daemonize-rabbitmq http://jaikoo.com/2008/3/14/oh-hai-rabbitmq http://jaikoo.com/2008/2/29/friday-round-up-2008-02-29 http://jaikoo.com/2007/9/4/didn-t-you-get-the-memo

Open Enterprise's series on messaging middleware and AMQP http://www1.interopsystems.com/analysis/can-amqp-break-ibms-mom-monopoly-part-1.html http://www1.interopsystems.com/analysis/can-amqp-break-ibms-mom-monopoly-part-2.html http://www1.interopsystems.com/analysis/can-amqp-break-ibms-mom-monopoly-part-3.html

Messaging and distributed systems resources:

A Critique of the Remote Procedure Call Paradigm http://www.cs.vu.nl/~ast/publications/euteco-1988.pdf

A Note on Distributed Computing http://research.sun.com/techrep/1994/smli_tr-94-29.pdf

Convenience Over Correctness http://steve.vinoski.net/pdf/IEEE-Convenience_Over_Correctness.pdf

Metaprotocol Taxonomy and Communications Patterns http://hessian.caucho.com/doc/metaprotocol-taxonomy.xtp

Joe Armstrong on Erlang messaging vs RPC http://armstrongonsoftware.blogspot.com/2008/05/road-we-didnt-go-down.html

SEDA: scalable internet services using message queues http://www.eecs.harvard.edu/~mdw/papers/seda-sosp01.pdf)

http://data.nantes.fr/donnees/detail/offres-de-services-des-parkings-publics-de-la-ville-de-nantes-1/?visualization=2

Data tells you whether to use A or B. Science tells you what A and B should be in the first place.

http://www.estv2.admin.ch/d/dokumentation/zahlen_fakten/tax_freedom_day/2011/index.htm

http://www.mblondel.org/data/amazon7.pkl.tar.bz2 try: import joblib except ImportError: from sklearn.externals import joblib

data = joblib.load("amazon7.pkl") X = data["X"] y = data["y"] print X.shape print y.shape print data["categories"]

Operations-improver Splunk Tech-trend tracker Quid Data scientist tournament host Kaggle Credit rating revolutionary ZestFinance Electronic medical record streamliner Apixio Business intelligence visualizer Datameer Marketing modeler BlueKai Enterprise social media simplifier Gnip Brick-and-mortar customer analyzer RetailNext Compliance catalyst Recommind

Supersonic is an ultra-fast, column oriented query engine library written in C++. It provides a set of data transformation primitives which make heavy use of cache-aware algorithms, SIMD instructions and vectorised execution, allowing it to exploit the capabilities and resources of modern, hyper pipelined CPUs. It is designed to work in a single process.

Kafka, another open source tool that Kreps called “the big data equivalent of a message broker.” http://engineering.linkedin.com/data-replication/open-sourcing-databus-linkedins-low-latency-change-data-capture-system opensource project http://data.linkedin.com/opensource/bob

http://techblog.netflix.com/2012/06/netflix-recommendations-beyond-5-stars.html

https://github.com/tjake/rbm-dbn-mnist

http://david-hu.com/2011/11/02/how-khan-academy-is-using-machine-learning-to-assess-student-mastery.html

• AMPLab – Mesos, plus BDAS Berkeley Data Analytics Stack
• Cascading/Cascalog/Scalding, not limited to Hadoop since other topologies are possibles;
• Twitter – Summingbird, Storm, etc.;
• Facebook – Presto;
• Anaconda/IPython/Pandas;
• Actian/ParAccel/Knime,

"That workflow abstraction is important. For example, PMML has excellent features for ensembles and other complex patterns encountered in the more competitive areas of industry."

https://github.com/yods/storm-ml-play http://skillsmatter.com/event/java-jee/machine-learning-with-storm-redis https://github.com/MastodonC/r4f-data

Main component hekad http://hekad.readthedocs.org/en/latest/

http://melmeric.files.wordpress.com/2013/04/samoa-a-platform-for-mining-big-data-streams.pdf

http://blog.comsysto.com/2013/04/03/background-of-collaborative-filtering-with-mahout/

https://github.com/amueller/sklearn_tutorial/blob/master/ml_with_sklearn_notebook.ipynb http://nbviewer.ipython.org/5115540/Model%20Selection%20for%20the%20Nystroem%20Method.ipynb

loglog counting , Frequency Estimation: Count-Min Sketch, Heavy Hitters: Stream-Summary Range Query: Array of Count-Min Sketches Membership Query: Bloom Filter

http://en.wikipedia.org/wiki/Randomized_controlled_trial http://www.amazon.com/Causality-Reasoning-Inference-Judea-Pearl/dp/0521773628

http://en.wikipedia.org/wiki/Large_Margin_Nearest_Neighbor http://en.wikipedia.org/wiki/Neighbourhood_components_analysis

kNN classifier to recognize digits

http://simplystatistics.org/2012/08/27/a-deterministic-statistical-machine/

introduction: nline linear learning: Lecture 2 2nd order methods and analysis of convergence: Demos in Torch BFGS and Limited Storage BFGS: Lecture 3 Online learning for non-linear/non-convex models: Boosted decision trees (guest lecture by Tong Zhang) Example code in R Lecture 4 Hadoop All-Reduce; Lecture 5 Torch tutorial; torch basics; machine learning tutorial; video CUDA tutorial (by Matthew Zeiler); PDF part 1; PDF part 2; video; video for Torch 7 CUDA demo Lecture 6 Feature learning, representation learning; Lecture 7 Feature learning, deep learning;

Lecture 8 Inverted Indicies and predictive indexing, hashing Project ideas description video John Langford's projects Xiang Zhang's projects Yann LeCun's projects Lecture 9 The ad problem, advertising placement and such (guest lecturer: Leon Bottou, Microsoft Research) Lecture 10 Classic and advanced bandits (John Langford) Lecture 11 Counterfactual reasoning (Leon Bottou) Advanced topics (John Langford) Lecture 12 Active Learning, Indexing (John Langford) Slides: PDF Video Lecture 13 Deep Learning in Text and Speech Recognition Lecture 14 : Many Classes, Logarithmic-Time Prediction

faces http://www.facegroup.com/casestudies/o2-real-time-o2

Churn Prediction , Sentiment Analysis, Truth Veracity ,Recommendations, online Ads, News Aggregations, Scalability , Content Discovery/Search Inteligent learning , medicine

https://github.com/jngiam/sparseFiltering

Theoretical Neuroscience: Computational and Mathematical Modeling of Neural Systems by Peter Dayan and Larry Abbott http://www.gatsby.ucl.ac.uk/~dayan/book/

http://openclassroom.stanford.edu/MainFolder/CoursePage.php?course=MachineLearning https://class.coursera.org/ml/lecture/preview

http://en.wikipedia.org/wiki/Deep_learning#Deep_Learning_in_Artificial_Neural_Networks http://jeremydhoon.github.io/2013/03/19/abusing-hash-kernels-for-wildly-unprincipled-machine-learning/

http://zurichtechtalks.ch/post/37339409724/an-introduction-to-cloudera-impala-sql-on-top-of meetup http://www.bigdata-usergroup.ch/item/372881

http://slendrmeans.wordpress.com/2013/02/08/will-it-python-machine-learning-for-hackers-chapter-6-regression-models-with-regularization/

http://nsaunders.wordpress.com/2010/08/20/a-brief-introduction-to-apply-in-r/

data consistency , data placement, system coordination

https://docs.google.com/spreadsheet/ccc?key=0AlHPKx74VyC5dERyMHlLQ2lMY3dFQS1JRExYQUNhdVE#gid=0

http://www2.research.att.com/~yifanhu/software.html

@wardnyt Sports Graphics Editor http://nytimes.com Matthew Ericson @mericson Deputy Graphics Director at The New York Times New York, NY · ericson.net Jeremy White @blueshirt Graphics editor for The New York Times, while also pursuing a PhD in geography with an emphasis on interactive cartography New York City · blueshirt.com

http://www.openculture.com/2013/05/the_art_of_data_visualization_.html Data Visualization History goes together with Science history ( Maps, Galileo …)

source viz in python cairo https://github.com/natronics/ISS-photo-locations/

http://blog.revolutionanalytics.com/2013/04/extending-revoscaler-for-mining-big-data.html http://blog.revolutionanalytics.com/2013/04/visualize-large-data-sets-with-the-bigvis-package.html

http://www.peachpit.com/store/functional-art-an-introduction-to-information-graphics-9780321834737

http://www.edwardtufte.com/tufte/dapp/

install gdal to be able to convert shape file into GeoJSON : ~/dev/misc/gdal-1.9.2/apps/ogr2ogr -f GeoJSON -where "iso_a2 = 'CH' AND SCALERANK < 8" ch_places.json ~/tmp/ne_10m/ne_{10mpopulatedplaces}.shp to get shapefiles : http://gadm.org/download

http://objectcommando.com/blog/2011/11/04/the-magical-island-of-kanren-core-logic-intro-part-1/ datalog for lucene query https://groups.google.com/forum/?fromgroups=#!topic/clojure/_M73qeHNFe8 https://gist.github.com/3060305

Usage of name-vars

(?- (stdout) (c/first-n (name-vars age ["?person" "?age"]) 10 :sort "?age" :reverse true))

The name-vars portion is necessary because the age dataset is just a vector without named fields.

https://github.com/ztellman/riddley

riddley.walk> (walk-exprs number? inc '(let [n 1] (+ n 1))) (let* [n 2] (. clojure.lang.Numbers (add n 2)))

how to write a correct macroexpand-all (which requires a code walker) in Common Lisp: http://www.merl.com/publications/TR1993-017/

I think functions like this become pretty clear if you pull out 'unfold' and 'fold' utilites, like: https://github.com/Prismatic/plumbing/blob/master/src/plumbing/map.clj#L42

Their 'flatten' generates a seq [path value] pairs, and 'unflatten' turns that back into a map. With these, you can write your functions

(defn to-map [kv-seq] (into {} kv-seq)) ;; utility

(defn flatten-map [m kf vf] (->> m flatten (map (fn ks v [(kf ks) (vf v)])) to-map))

(defn mapf [m f & args] (->> m flatten (map (fn ks v [ks (apply f v args)])) unflatten))

(defn deep-merge-with [f & ms] (->> ms (map flatten) (map to-map) (reduce (fn [res m] (merge-with f res m))) ;; could use 'partial' unflatten))

(defn deep-merge [a b] (deep-merge-with (fn [x y] y) a b))

;; bonus: also useful for fns that don't return a map (defn max-depth [m] (->> m flatten (map (comp count first)) (apply max 0)))

(defn deep-merge "Recursively merges maps. If keys are not maps, the last value wins." [& vals] (if (every? map? vals) (apply merge-with deep-merge vals) (last vals)))

(let [{x (+ 1 1)} {2 "two"}] x)

https://github.com/cgrand/parsley/blob/master/src/net/cgrand/parsley/tree.clj#L15

(into {} (for …)) (defn keywordize-keys "Recursively transforms all map keys from strings to keywords." {:added "1.1"} [m] (let [f (fn k v] (if (string? k) [(keyword k) v] [k v]))] ;; only apply to maps (postwalk (fn [x] (if (map? x) (into {} (map f x)) x)) m))

https://github.com/sonian/carica/commit/eae079f4bfd1a0d50a75b11cd0f23ca73ec81797 (require 'cheshire.core) (apply (ns-resolve (symbol "cheshire.core") (symbol "parse-stream")) args)

(memfn getPath) instead of #(.getPath %) (defmulti load-config (comp second (partial re-find #"\.([^..]*?)$") (memfn getPath)))

(defmethod load-config "clj" [resource])

(into {} (doto (java.util.Properties.) (.load (-> (Thread/currentThread) (.getContextClassLoader) (.getResourceAsStream "log4j.properties")))))

user> (defn test1 [coll] (reduce + coll)) user> (test1 (take 10000000 (iterate inc 0))) 49999995000000 user>

Now if we do:

user> (defn test2 [coll] [(reduce + coll) (reduce + coll)]) user> (test2 (take 10000000 (iterate inc 0))) OutOfMemoryError Java heap space [trace missing]

Clojure has a feature called locals clearing, which sets 'coll to nil before calling reduce in test1, because the compiler can prove it won't be used afterwards. In test2, coll has to be retained, because reduce is called a second time on it. https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/Compiler.java#L3458

Like merge-with, but merges maps recursively, applying the given fn only when there's a non-map at a particular level.

(deepmerge + {:a {:b {:c 1 :d {:x 1 :y 2}} :e 3} :f 4} {:a {:b {:c 2 :d {:z 9} :z 3} :e 100}}) -> {:a {:b {:z 3, :c 3, :d {:z 9, :x 1, :y 2}}, :e 103}, :f 4}

https://groups.google.com/forum/?fromgroups=#!topic/clojure/YBkUaIaRaow

promise - creates a object that can be deref'd. The result of the promise can be delivered once, and deref-ing a undelivered will cause the deref-ing thread to block. A single producer can give a single value to multiple threads

future - just like a promise, but it the delivering code is given to the future and the future will go off and execute that code in a different thread. Single producer delivers a single value produced in a undefined thread, to multiple consumers

agents - couples a unbounded queue of functions with a single mutable value. Mutating that value is accomplished by enqueue'ing functions to be executed against that mutable state. Multiple producers use functions to modify a mutable ref. Can be deref-ed by may different consumers

channels - allow multiple producers to provide data to multiple consumers on a one-to-one basis. That is to say, a single value put into a channel can only be taken by a single consumer. However, multiple values can be inflight at a single time. This is all delivered by a bounded queue (notice the difference with unbounded agents). This allows for back-pressure, where slow producers can block faster consumers. So perhaps the best way to think about channels is a bounded mutable queue of promises

http://blog.getprismatic.com/blog/2013/7/10/introducing-hiphip-array-fast-and-flexible-numerical-computation-in-clojure

(ns test.nio2.test.tail (:use clojure.java.io nio2.io nio2.watch nio2.files))

(defn tail [n p] "Print the last n lines of path p to stdout" (with-open [rdr (reader p)] (doseq [l (take-last n (line-seq rdr))] (println l)) (doseq [e (watch-seq (parent (real-path p)) :modify)] (when (= (real-path (:path e)) (real-path p)) (while (.ready rdr) (println (.readLine rdr)))))))

Parallel universes for namespaces https://github.com/technomancy/metaverse

http://corfield.org/blog/post.cfm/real-world-clojure-logging http://www.paullegato.com/blog/log4j-clojure/ http://gphil.net/posts/2012-09-04-logging-in-clojure.html simple concrete example

https://github.com/xavi/noir-auth-app/blob/master/src/noir_auth_app/views/admin.clj#L30-L102 https://groups.google.com/forum/#!topic/enlive-clj/EJWSH5G7rH0

good (.-MAX_NUMBER js/Math) and (.ceil js/Math 3.14) not clojure compatible js/Math.MAX_NUMBER and (js/Math.ceil 3.14)

https://github.com/prismatic/cljs-test https://github.com/cemerick/yonder

https://github.com/alandipert/enduro-todo

https://groups.google.com/forum/?fromgroups=#!topic/clojure/-kEXiuDRejE

Fast JVM launching without the hassle of persistent JVMs. https://github.com/flatland/drip/

> I take this to mean that there's no widely accepted solution.

The widely-accepted solution is to leave a single process running. It certainly has limitations, but it's the way most people deal with the problem. > Really, I just want `lein run` to be faster. Can someone explain where all > this time is spent?

Basically it comes from having to load two JVMs, one for Leiningen itself and one for the project. Leiningen itself is fairly optimized for this (fully AOTed, bytecode verification is turned off, fancy warm-up JIT techniques disabled) which is why it's possible to get `lein version` to return in under a second in some cases. But there are various compatibility issues that prevent us from being able to perform the same optimizations on project JVMs. These are documented on the "Faster" page of the Leiningen wiki, and you can do some testing to determine whether or not they affect your project in particular; if not then they should provide a good boost. But nothing will ever come close to the speed of keeping the JVM resident, which is why I'm working on `:eval-in :nrepl` and lein.el. For people who don't use Emacs, Jark is the only tool I'm aware of that is working towards this in a way that's decoupled from the editor. They could probably use some help both testing and implementing it. > I hear a lot of talk of compiling, but why would we re-compile things where > none of the dependencies have changed?

Performing a full AOT of all your dependencies will help if you have a large project with lots of dependencies that get loaded at application boot. But that effect would be something along the lines of bringing boot down from 20s to 12s rather than bringing it from 5s to <1s.

(with-out-str (print-table [{:a 1 :b 2 :c 3} {:b 5 :a 7 :c "dog"}]))

(Using with-out-str is needed because print-table of course returns nil)

But what I get when generating HTML (via "C-c C-e b") is not a table, but the literal text of the table markup. I.e. compiling the above source block yeilds:

Flipboard Instapaper Pinterest Prismatic Tumblr

http://linuxaria.com/article/installation-of-seafile-open-source-dropbox-alternative-for-teams?lang=en http://techcrunch.com/2013/02/24/meet-owncloud-5-the-open-source-dropbox/

• hacking and reverse-engineering projects (TBD)
• web crawling projects: how many Facebook accounts are duplicate or dead? Or categorize Tweets
• taxonomy creation or improving an existing taxonomy
• optimal pricing for bid keywords on Google
• create a web app that provide (in real time) better-than-average trading signals
• find low-frequency and Botnet fraud cases in a sea of data
• internship in computational marketing with a data science start-up
• automated plagiarism detection
• use web crawlers, assess whether Google Search favors
  • (1) its products over competitors [is this an unfair business practice?],
  • (2) local over non-local results and
  • (3) returns different results to web robots and humans. Identify other bias and patterns in Google search results.

Classroom flipping means assigning lectures as homework, leaving actual classroom time for hands-on instruction and group work. Ng told me his class at Stanford is already doing this, and he’s encouraging other professors to adopt the approach for their Coursera classes as well.