simple_rgb_cube.clj

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Simple 3d Clojure code example for Incanter and Processing
; Adapted by James Swift (james at 3dengineer com)
; from the simple_interation.clj example that comes with incanter
; and the RGB cube example here http://processing.org/learning/3d/rgbcube.html

(ns example
  (:use [incanter core processing]))

;; set up variable references to use in the sketch object

swannodette

(ns match.java
  (:refer-clojure :exclude [compile])
  (:use [match.core]))

(extend-type java.util.Date
  IPLookup
  (p-val-at [this key]
    (case key
          :year    (.getYear this)
          :month   (.getMonth this)

danstuken

(define (script-fu-xcf2jpg-batch xcfDirectory inQuality)
  (let* ((xcfList (cadr (file-glob (string-append xcfDirectory "/*.xcf") 1))))
    (while (not (null? xcfList) )
      (let* ((xcfFilename (car xcfList))
        (jpgFilename (string-append (substring xcfFilename 0 (- (string-length xcfFilename) 4) ) ".jpg"))
        (xcfImage    (car (gimp-file-load RUN-NONINTERACTIVE xcfFilename xcfFilename)))
        (xcfDrawable (car (gimp-image-flatten xcfImage))) )
        (file-jpeg-save RUN-NONINTERACTIVE xcfImage xcfDrawable jpgFilename jpgFilename
              inQuality 0.0 0 0 "" 0 1 0 2)
        )

arvearve

Mathematics: What do grad students in math do all day?

by Yasha Berchenko-Kogan

A lot of math grad school is reading books and papers and trying to understand what's going on. The difficulty is that reading math is not like reading a mystery thriller, and it's not even like reading a history book or a New York Times article.

The main issue is that, by the time you get to the frontiers of math, the words to describe the concepts don't really exist yet. Communicating these ideas is a bit like trying to explain a vacuum cleaner to someone who has never seen one, except you're only allowed to use words that are four letters long or shorter.

What can you say?

nn.clj

(ns martha.core
  (:require [clojurewerkz.titanium.graph    :as g]
            [clojurewerkz.titanium.vertices :as v]
            [clojurewerkz.titanium.edges    :as e]
            [clojurewerkz.titanium.types    :as t]
            [ogre.core                      :as q]))

(def conf {:storage {:backend "embeddedcassandra"
                     :hostname "127.0.0.1"
                     :keyspace "martha"

PetrGlad

shopt -s histappend

export PATH=$PATH:$HOME/.local/bin:$HOME/bin

stty -ixon 
# export PS1='\n\[\e]0;\u@\h: \w\a\]${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]`__git_ps1` \n\$ '
# export PS1='\n\[\e]0;\u@\h: \w\a\]${debian_chroot:+($debian_chroot)}\[\033[38;5;250m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\[\033[38;5;250m\]`__git_ps1`\[\033[00m\] \n\[\033[01;32m\]☯\[\033[00m\]  '
# export PS1='\n\[\e]0;\u@\h: \w\a\]${debian_chroot:+($debian_chroot)}\[\033[38;5;243m\]\u@\h\[\033[00m\]:\[\033[38;2;140;140;200m\]\w\[\033[00m\]\[\033[38;5;243m\]`__git_ps1`\[\033[00m\] \n\[\033[01;32m\]☯\[\033[00m\]  '
export PS1='\n\[\e]0;\u@\h: \w\a\]${debian_chroot:+($debian_chroot)}\[\033[38;5;243m\]\u@\h\[\033[00m\]:\[\033[38;2;140;140;200m\]\w\[\033[00m\]\[\033[38;5;243m\]`__git_ps1`\[\033[00m\] \n\[\033[01;3`[ $(id -u) == "0" ] && echo 3 || echo 2`m\]☯\[\033[00m\] '

tonsky

{ :+
  { :editor
    { "pmeta-/"           [:toggle-comment-selection]
      "ctrl-shift-up"     [:editor.sublime.selectLinesUpward]
      "ctrl-shift-down"   [:editor.sublime.selectLinesDownward]
      "pmeta-d"           [:editor.sublime.selectNextOccurrence]
      "ctrl-m"            [:editor.sublime.goToBracket]
      "ctrl-shift-m"      [:editor.sublime.selectBetweenBrackets]
      "shift-pmeta-space" [:editor.sublime.selectScope]
      "ctrl-pmeta-up"     [:editor.sublime.swapLineUp]

evancz

Architecture in Elm

This document is a collection of concepts and strategies to make large Elm projects modular and extensible.

We will start by thinking about the structure of signals in our program. Broadly speaking, your application state should live in one big foldp. You will probably merge a bunch of input signals into a single stream of updates. This sounds a bit crazy at first, but it is in the same ballpark as Om or Facebook's Flux. There are a couple major benefits to having a centralized home for your application state:

1. There is a single source of truth. Traditional approaches force you to write a decent amount of custom and error prone code to synchronize state between many different stateful components. (The state of this widget needs to be synced with the application state, which needs to be synced with some other widget, etc.) By placing all of your state in one location, you eliminate an entire class of bugs in which two components get into inconsistent states. We also think yo

croepha

// This will open up a prompt for text to send to a console session on digital ocean
//  Useful for long passwords
(function () {        
        var t = prompt("Enter text to be sent to console, (This wont send the enter keystroke)").split("");
        function f() {
                
                var character = t.shift();
                var i=[];
                var code = character.charCodeAt();
                var needs_shift = "!@#$%^&*()_+{}:\"<>?~|".indexOf(character) !== -1

reborg

Rich Already Answered That!

A list of commonly asked questions, design decisions, reasons why Clojure is the way it is as they were answered directly by Rich (even when from many years ago, those answers are pretty much valid today!). Feel free to point friends and colleagues here next time they ask (again). Answers are pasted verbatim (I've made small adjustments for readibility, but never changed a sentence) from mailing lists, articles, chats.

How to use:

• The link in the table of content jumps at the copy of the answer on this page.
• The link on the answer itself points back at the original post.

Table of Content