michaelsbradleyjr

(ns my-cljs.macros.debug
  (:require [cljs.analyzer :as cljs]
            clojure.walk))

(declare ap
         cljs-macroexpand*
         cljs-macroexpand-1*
         cljs-macroexpand-all*

         cljs-macroexpand

ritalin

package sample.converters;

import java.sql.SQLException;

import org.joda.time.Period;
import org.postgresql.util.PGInterval;
import org.seasar.doma.ExternalDomain;
import org.seasar.doma.jdbc.domain.DomainConverter;

@ExternalDomain

martintrojer

;; ------------------------

(defn- log-time [{:keys [ns name line]} f & args]
  (let [start   (System/nanoTime)
        res     (apply f args)
        elapsed (quot (- (System/nanoTime) start) 1000)]
    (log/debug (format "%s/%s:%s %dus" ns name line elapsed))
    res))

(defn enable-timing [var]

telent

App configuration in environment variables: for and against

For (some of these as per the 12 factor principles) 

1) they are are easy to change between deploys without changing any code

2) unlike config files, there is little chance of them being checked
into the code repo accidentally

3) unlike custom config files, or other config mechanisms such as Java

qtrfeast

(defn keyword->pg-enum
  "Convert a keyword value into an enum-compatible object."
  [enum-type kw]
  (doto (org.postgresql.util.PGobject.)
    (.setType enum-type)
    (.setValue (name kw))))
    
(def ->status
  "Convert a keyword status into a something_status enum object"
  (partial keyword->pg-enum "something_status"))

daveliepmann

(ns localstorage)

(defn set-item!
  "Set `key' in browser's localStorage to `val`."
  [key val]
  (.setItem (.-localStorage js/window) key val))

(defn get-item
  "Returns value of `key' from browser's localStorage."
  [key]

favila

(ns favila.async-util
  "Some missing pieces of core.async.

   as-transducer: Make a transducer function easily without Clojure 1.7.
   go-pipe: async/pipe, but returns the go-loop.
   fast-pipeline-blocking: faster than async/pipeline-blocking, but unordered results.
   blocking-consumer: consume a channel with multiple worker threads."
  (:require [clojure.core.async :as async
             :refer [go go-loop <! >! <!! >!! close! take! put! chan]]))

Deraen

(ns metosin.common.edn
  #+clj
  (:require [clj-time.format :as f])
  #+cljs
  (:require [cljs-time.format :as f]
            cljs.reader)
  #+clj (:import [org.joda.time DateTime LocalDate]))

;;
;; #DateTime tagging

kennwhite

Most VPN Services are Terrible

Short version: I strongly do not recommend using any of these providers. You are, of course, free to use whatever you like. My TL;DR advice: Roll your own and use Algo or Streisand. For messaging & voice, use Signal. For increased anonymity, use Tor for desktop (though recognize that doing so may actually put you at greater risk), and Onion Browser for mobile.

This mini-rant came on the heels of an interesting twitter discussion: https://twitter.com/kennwhite/status/591074055018582016

vvvvalvalval

;; Synchronous Clojure trained us to use Exceptions, while asynchronous JavaScript has trained us to use Promises.
;; In contexts where we work asynchronously in Clojure (in particular ClojureScript), it can be difficult to see a definite way of managing failure. Here are some proposals.

;; OPTION 1: adapting exception handling to core.async CSPs
;; As proposed by David Nolen, with some macro sugar we use Exceptions in go blocks with core async in the same way we would do with synchronous code.

(require '[clojure.core.async :as a :refer [go]])

;; defining some helper macros
(defn throw-err "Throw if is error, will be different in ClojureScript"