Forem: Cora Sutton

Incognito for Shell Commands

Cora Sutton — Fri, 06 Jan 2023 00:02:26 +0000

We're usually careful not to store secrets in places easily accessible to others. We even do chmod 600 on our keys in ~/.ssh to prevent other users from reading it. There's one place, however, that we often forget to be careful about: our shell history files. Luckily, there are ways to prevent our commands that set or use secrets from entering our shell history. The following are instructions for how to go "incognito" for individual commands and prevent them from being logged in our shell history files.

Zsh

zsh has an option that's perfect for this: HIST_IGNORE_SPACE. It even keeps the command around in-memory so you can execute it again if you need to while never writing it to disk.

The manpage has this to say about the option:

HIST_IGNORE_SPACE (-g)

  Remove command lines from the history list when the first character
  on the line is a space, or when one of the expanded aliases
  contains a leading space.  Only normal aliases (not global or
  suffix aliases) have this behaviour.  Note that the command lingers
  in the internal history until the next command is entered before it
  vanishes, allowing you to briefly reuse or edit the line.  If you
  want to make it vanish right away without entering another command,
  type a space and press return.

To begin using this you can call setopt HIST_IGNORE_SPACE in your shell. To have this enabled by default for your shell you can add it to ~/.zshrc.

You can see this option and more using man zshoptions.

Bash

bash also has an option for this: HISTCONTROL. Here's the manpage entry for that option:

HISTCONTROL

  A colon-separated list of values controlling how commands are saved
  on the history list.  If the list of values includes ignorespace,
  lines which begin with a space character are not saved in the
  history list.  A value of ignoredups causes lines matching the
  previous history entry to not be saved.  A value of ignoreboth is
  shorthand for ignorespace and ignoredups.  A value of erasedups
  causes all previous lines matching the current line to be removed
  from the history list before that line is saved.  Any value not in
  the above list is ignored.  If HISTCONTROL is unset, or does not
  include a valid value, all lines read by the shell parser are saved
  on the history list, subject to the value of HISTIGNORE.  The
  second and subsequent lines of a multi-line compound command are
  not tested, and are added to the history regardless of the value of
  HISTCONTROL.

You should check what the current value for HISTCONTROL is using echo $HISTCONTROL. You can keep the current value or modify it to your liking and add it to your ~/.bash_profile using export HISTCONTROL=ignorespace.

Note that there are other possible values for this and you should read the manpage entry above (or man bash) for more details.

New Clojure Morsels!

Cora Sutton — Wed, 15 Sep 2021 01:23:24 +0000

Clojure Morsels

@clojuremorsels

Hi, babes! It’s that time again! A new edition, hot off the presses and (hopefully) in your inbox. There is a *lot* going on in the Clojure world lately and it feels great to help you keep up with it, if only a little bit. (💜) -@corasaurus_hex

mailchi.mp/clojuremorsels…

01:16 AM - 15 Sep 2021

The Good, the Bad, and the Accumulators.

Cora Sutton — Wed, 21 Jul 2021 23:11:29 +0000

In programming it's common to need to accumulate a value. How you go about that in Clojure is a bit different from many other languages. In this post we'll go over some good ways and some not-so-good ways to accumulate values in Clojure.

The Not-so-good

Def in a function

If you're used to assigning to a value and then incrementing it, you might try something like this. Using def in a function like this, however, actually sets the value globally. If you have two threads calling this function at the same time you're going to get some wonky behavior.

(defn my-fn1 []
  (def my-variable1 1)
  (doseq [x (range 0 10)]
    (def my-variable1 (+ my-variable1 x))))

(my-fn1)

(println "oops, my-variable1 is" my-variable1)
;; oops, my-variable is 46

Using an atom

Atoms are great! So are refs! They're really for safely changing data from multiple threads safely, though. There's an expense to using them that you just don't want to pay unless you're using multiple threads and so it's best to avoid them in cases like this.

(defn my-fn2 []
  (let [my-variable2 (atom 1)]
    (doseq [x (range 0 10)]
      (swap! my-variable2
             (fn [current-value]
               (+ current-value x))))
    (println "hi, my-variable2 is" @my-variable2)))

(my-fn2)
;; hi, my-variable2 is 46

Volatile!

Volatile does work in this case but while volatile is faster than atoms it also has performance implications.

(defn my-fn3 []
  (let [my-variable3 (volatile! 1)]
    (doseq [x (range 0 10)]
      (vswap! my-variable3 (fn [current-value] (+ current-value x))))
    (println "hello, my-variable3 is" @my-variable3)))

(my-fn3)
;; hello, my-variable3 is 46

The Good

Reduce v1!

Reduce! Now we're getting Clojure-y! This is a typical way to accumulate values in Clojure. You can do this with hashmaps, maps, sums, sets, etc, really anything at all. Reduce will go through each value in the range and pass in the previous accumulator value (or the starting value) and the current value in the range. The value returned from the function passed to reduce will be the new value for the accumulator. Once it runs out of values in the range the current value of the accumulator will be returned.

Also, you can skip sending a starting value and then the first accumulator value is the first value in the range!

(defn my-fn4 []
  (let [starting-value 1
        my-variable4 (reduce (fn [accumulator value]
                               (+ accumulator value))
                             starting-value
                             (range 0 10))]
    (println "omg, my-variable4 is" my-variable4)))

(my-fn4)
;; omg, my-variable4 is 46

In this case we can just pass + as the function.

(defn my-fn5 []
  (let [starting-value 1
        my-variable5 (reduce +
                             starting-value
                             (range 0 10))]
    (println "yay, my-variable5 is" my-variable5)))

(my-fn5)
;; yay, my-variable5 is 46

Loop/recur

Loop/recur is another essential way to handle this problem in Clojure. While I might not use it for adding up numbers I will use it for all kinds of other accumulations or complex behavior when looping over a sequence of values.

(defn my-fn6 []
  (loop [my-variable6 1
         values (range 0 10)]
    (let [value (first values)]
      (if value
        (recur (+ my-variable6 value)
               (rest values))
        (println "so, ok, my-variable6 is" my-variable6)))))

(my-fn6)
;; so, ok, my-variable6 is 46

The Conclusion

It takes a little getting used to but eventually it feels a little uncontrolled and bug-prone to accumulate values the way some other languages do it.

Read environment variables in Clojure

Cora Sutton — Thu, 15 Jul 2021 20:13:50 +0000

Do you want to load some configuration values from the environment in Clojure?

Great news! Clojure makes this easy!

(System/getenv "SHELL")
;=> /usr/local/bin/zsh

There are many other ways to configure your Clojure application, and some of us have our favorites, but environment variables often factor in.

Give it a shot and see what you can learn!

New Clojure Morsels!

Cora Sutton — Thu, 15 Jul 2021 18:22:23 +0000

I just pushed our first widely distributed edition of Clojure Morsels!

I'm really proud of this one (especially the cupcake), so check it out!

Announcing Clojure Morsels

Cora Sutton — Thu, 01 Jul 2021 18:49:37 +0000

I’m happy to announce that we have started a totally free newsletter called Clojure Morsels! In it you’ll find links and summaries about all kinds of Clojure-related topics, from articles to tools to tutorials to jobs. You can find out more about it on our Twitter account. Let us know if you enjoy it and/or have feedback!

You can find me as @cora on Clojurians Slack if you want to chat.