cstorey

Adrian -

I appreciate that you spent time in writing this post. I know I've been up until 2am writing similarly long ones as well. I will take responsibility for having what is likely an irrational response (I blame Twitter for that) to the term "NoOps", but I invite you to investigate why that might be. I'm certainly not the only one who feels this way, apparently, and thus far have decided this issue is easily the largest distraction in my field I've encountered in recent years. I have had the option to simply ignore my opposition to the term, and just let the chips fall where they may with how popular the term "NoOps" may or may not get. I have obviously not taken that option in the past, but I plan to in the future.

You're not an analyst saying "NoOps". Analysts are easy (for me) to ignore, because they're not practitioners. We have expectations of engineering maturity from practitioners in this field of web engineering, especially those we consider leaders. I don't have any expectations from analysts,

	;annotation syntax

	(import [java.lang.annotation Retention RetentionPolicy Target ElementType]
	[javax.xml.ws WebServiceRef WebServiceRefs])
	(definterface Foo (foo []))

	;annotation on type
	(deftype ^{Deprecated true
	Retention RetentionPolicy/RUNTIME
	javax.annotation.processing.SupportedOptions ["foo" "bar" "baz"]

	#!/bin/bash
	#
	# Find all processes that are executing a futex(2) call with op=FUTEX_WAIT
	# In some cases this can be helpful in finding deadlock-ed processes.
	#

	test ! $UID -eq 0 && echo -e "WARNING: Not running as root, only processes for this user are being scanned\n" >&2;
	pids=$(ps -u $UID -opid --no-headers)

	for pid in $pids; do

	(ns com.snowtide.clojure.memoize)

	(defn- mutable-memoize
	[f #^java.util.Map map]
	(fn [& args]
	(if-let [e (find map args)]
	(val e)
	(let [ret (apply f args)]
	(.put map args ret)
	ret))))

	(ns fj
	(:import [java.util.concurrent RecursiveTask
	ForkJoinPool]))

	(set! warn-on-reflection true)

	;; -----------------------------------------------
	;; Helpers to provide an idiomatic interface to FJ

	(defprotocol IFJTask

	;; Copyright (c) Alan Dipert. All rights reserved.
	;; The use and distribution terms for this software are covered by the
	;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
	;; By using this software in any fashion, you are agreeing to be bound by
	;; the terms of this license.
	;; You must not remove this notice, or any other, from this software.

	(ns alandipert.kahn
	(:require [clojure.set :refer [difference union intersection]]))

	module Main where

	import Test.QuickCheck (quickCheck)
	import Your.Module (encrypt, decrypt)

	prop_reverseReverse :: [Char] -> Bool
	prop_reverseReverse s = (reverse . reverse) s == s

	prop_encryptDecrypt :: [Char] -> Bool
	prop_encryptDecrypt s = (encrypt . decrypt) s == s

	Greg's Stop Loss Kata

	Testing is very hard when time is involved ...

	A trailing stop loss is a term used in financial trading. For a very in depth explanation you can read here http://www.investopedia.com/articles/trading/03/080603.asp and http://en.wikipedia.org/wiki/Order_(exchange)#Stop_orders

	However we do not need a huge amount of background in order to do the kata as we are going to limit the problem a bit.

	The general idea is that when you buy into a stock at a price say $10. You want it to automatically get sold if the stock goes below $9 (-$1). If we use the term "trailing" that means that id the price goes up to $11 then the sell point becomes $10.

	(defn clj->js
	"Recursively transforms ClojureScript maps into Javascript objects,
	other ClojureScript colls into JavaScript arrays, and ClojureScript
	keywords into JavaScript strings."
	[x]
	(cond
	(string? x) x
	(keyword? x) (name x)
	(map? x) (.strobj (reduce (fn [m [k v]]
	(assoc m (clj->js k) (clj->js v))) {} x))

	// hotspot/src/share/vm/runtime/globals.hpp
	/*
	* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT