Individual Emails

Out of convenience, you have your contacts at Checkers email everyone on your team using their individual email address. This is the worst option. Why? If any of those people should no longer receive emails from Checkers, or any additional people should, it's extremely unlikely that you'll be able to get Checkers to update their lists. You're also likely to forget to tell them to update their info, especially if the communication is infrequent. After initial integration, it almost certainly will be.

Team Mailing List

If you give Checkers a team mailing list, teamawesome@coolcompany.com, you get to control who receives emails. Three months later, there's a reorg at Cool Company, and Team Awesome ceases to exist. Oof. This isn't a terrible outcome, but when someone in IT without context decides to delete this team mailing list without context, communication is severed.

Vendor Mailing List

Here's the best option. Make a group email address named for the vendor, checkers@coolcompany.com. That will survive any reorg at your company. You can have emails forward to any individual or group, including teamawesome@coolcompany.com. It's also unlikely to be deleted so long as people know this vendor is still in use. Cool Company or Checkers could still change their name. Still, that happens a whole lot less often than the other two scenarios above.

Summary

When giving email contact info to a vendor, your options are:

• Bad: me@mycompany.com

• Better: myteam@mycompany.com

• Best: vendor@mycompany.com

Homebrew offers two casks. claude-code tracks the stable release channel, which is typically about a week behind and skips releases with major regressions. claude-code@latest tracks the latest channel and receives new versions as soon as they ship.

https://code.claude.com/docs/en/overview#homebrew

So, I uninstalled claude-code and installed cloud-code@latest and I got the latest version!

There's another important note on that page:

Homebrew installations do not auto-update. Run brew upgrade claude-code or brew upgrade claude-code@latest, depending on which cask you installed, to get the latest features and security fixes.

• 2 c heavy cream

• 1 c whole milk

• 1/2 c white sugar

• 1/4 c brown sugar

• 1 Tbsp vanilla extract

• pinch of salt

Directions

1. Combine all ingredients into a bowl and mix.

2. Pour into two Creami jars.

3. Freeze 24 hours.

4. Mix on the Ice Cream setting.

Tips

Immersion Blender

When I mix the ingredients with an immersion blender, the ice cream's texture seems more like hard ice cream than soft serve.

Vanilla

Use the best vanilla extract you have since it's basically the entire flavor of the ice cream. I like homemade rum vanilla.

1/4 Cup Measuring Cup

If you use a 1/4 c measuring cup for the white sugar first (two scoops!), it will be clean for scooping the brown sugar. Then, you only have to get one measuring cup dirty.

Let The Mixture Rest

I've heard it said that after mixing you should refrigerate the mixture before freezing. This may help in two ways. First, it allows air bubbles to escape, which might help your Creami blend more smoothly. Second, it brings the entire mixture down to refrigerator temperature, which could reduce the time required to freeze, keeping ice crystals small. Smaller ice crystals mean creamier, smoother ice cream.

Some sellers don't charge a fee when paying via cash, debit card, or ACH transfer, but do when using a credit card. The fees I've experience are either flat or a percentage. I've wondered when the cash back becomes worth it. Let's break it down.

Flat Fees

My electric utility charges a $5 fee when paying via credit card and my credit card offers 3% cash back on everything (really, it's a Robinhood Gold Card). On a $100 charge, the cash back $3, less than the fee. On a $200 charge, the cash back is $6, exceeding the fee. Finding the break-even point is subtle. It's time for some math!

I'll use lower case letters, e.g. c, for percentage values and capital letters, e.g. C, for dollar amounts. First, I'll define terms:

• C cash back, e.g. $3 (say 3% on a $100 purchase)

• F fee, e.g. $5

• c cash back percentage, e.g. 3% or 0.03

• P purchase amount, e.g. $100

The cash back earned isn't on the base amount, it's on the bill plus the fee. We can express this as:

C = c(P + F)

Using the credit card is worth it when the cash back is at least equal to the fee:

C ≥ F

With a substitution:

c(P + F) ≥ F

At what purchase amount does it make sense to use the credit card? Let's isolate P :

c(P + F) ≥ F
cP +cF ≥ F
cP ≥ F - cF
P ≥ (F - cF) / c
P ≥ F (1 - c) / c

Let's test it using the $5 fee and 3% cash back from before:

P ≥ 5 (1 - 0.03) / 0.03
P ≥ 161.67

This checks out: 3% of $166.67 ($161.67 plus the $5 fee) is $5.

So, at purchase amounts higher than $161.67, I start making money.

Percentage Fees

When I pay my water bill via ACH, there is no fee. However, with a credit card, the fee is 3%. Most of us assume the credit card cash back percentage has to exceed the fee percentage to be worth it. As we established earlier, the cash back is based on the purchase amount plus the fee, not the purchase amount alone. Let's see what the math tells us:

• f fee percentage, e.g. 3% or 0.03

• C cash back, e.g. $3 (say 3% from a $100 purchase)

• F fee, e.g. $5

• c cash back percentage, e.g. 3% or 0.03

• P purchase amount, e.g. $100

How much is the fee?

F = fP

How much is the cash back?

C = c(P + F)
C = c(P + fP)
C = cP(1 + f)

Using a credit card makes sense once the cash back exceeds the fee. Let's isolate c:

C ≥ F
cP(1 + f) ≥ fP
c(1 + f) ≥ f
c ≥ f / (1 + f)

Note that the purchase amount doesn't matter.

Let's evaluate this with a 3% fee:

c ≥ 0.03 / (1 + 0.03)
c ≥ 0.02912621359

The cash back percentage doesn't need to be as large as the percentage fee!

Let's test that with an example. Say the bill is $100. With a 3% fee, the charge is $103. A cash back rate of 2.91% yields $3 in cash back and a cash back rate of 2.92% yields $3.01.

Conclusion

To determine whether using a credit card is worth it in the face of fees, remember:

• For flat fees, you have to do some math: P ≥ F (1-c) / c

• For percentage fees, having the cash back percentage equal to the fee percentage is always worth it. To arrive at the precise cash back percentage needed, use c ≥ f / (1 + f).

Footnote: Why did't I use LaTeX or Mathjax notation? I did. But, the Hashnode editor was very painful, and I experienced data loss. So, Italics it is.

Well, this was handy, https://kotlinlang.org/community/. I went through each of these resources. Unless stated otherwise, I got set up on July 14, 2026.

• Slack. I filled out the form and waited some number of days. I was invited to join on July 10, 2026. I quickly found my way to the #http4k channel. It's a little busier than the #reitit channel of the Clojurians Slack.

• X. I followed the Kotlin account. It seems to post more than once per day.

• Kotlin Blog. I use NetNewsWire and subscribed. Looks like there are a few posts a week.

• Reddit. Also joined. I expect I'll use this less than all of the above. That has more to do with me not being a big Reddit user than anything else.

• StackOverflow. I started watching the tag. I can't think of the last time I landed on StackOverflow.

• YouTube. Subscribed. I watched the KotlinConf '26 keynote back in June. It was a good overview of what's happening now in the language.

• Talking Kotlin. I use Overcast as my podcast player. I subscribed. It looks like the first episode was published January 11, 2017 and there are 145 episodes to date. The cadence seemed to be two a month at the start and now it looks like it's closer to monthly.

• LinkedIn. There seem to be some good posts.

• Issue Tracker. I don't think I'm going to use this.

• Awesome Kotlin. I'll definitely come back to this.

So far, my impression is that the Kotlin community is much more organized and larger and the Clojure and F# communities of which I have been a very happy participant. That probably isn't a surprise to anyone.

• its incredible REPL

• EDN

• keywords

• maps with heterogeneous keys and values

• structural editing

• beautiful, data-oriented Metosin libraries

• the big ideas

My journey learning Kotlin has begun!

What Are Vertical Tabs?

Tabs are tabs. When we say vertical or horizontal tabs, we're talking about how they're displayed. Vertical tabs are arranged in a vertical stack, instead of a horizontal list.

What's Wrong With Horizontal Tabs?

As horizontal tabs accumulate, they either have to get narrower (less legible) or be scrolled sideways, which is difficult to do with most mice (but not trackpads!).

Are Vertical Tabs New?

Vertical tabs in software applications aren't a new concept. After all, look this macOS Finder window with "tabs" Recents, Shared, etc.:

Tabs in Browsers

Many browsers have had horizontal tabs for a long time. Apparently, horizontal tabs in browsers first appeared in 1997 with SimulBrowse (later NetCaptor) by Adam Stiles. Mozilla picked up and popularized it in 2002. I love this snippet from the interview:

Did you have an "aha!" moment, when you realized that tabbed browsing would be a good thing to put in NetCaptor?

Adam Stiles: NetCaptor (originally SimulBrowse) was built from the beginning to be a tabbed browser. The HTML editor I was using at the time (HomeSite) had tabs, so I was used to flipping between a bunch of HTML documents. I wanted the same thing in my browser, so I built it. At first it was just an experiment to see if I could do it.

From developer tools to the mainstream!

Vertical Tabs in Browsers

From what I can gather, Opera got vertical tabs in 2005. Chrome had an early version that was scrapped, but it officially got them back on April 7, 2026.

Why Leave Arc?

If Arc was working for me, why switch back to Chrome? Well, I use Claude at work and I can't get the currently experimental Claude for Chrome extension to work with Arc.

Enabling Vertical Tabs in Google Chrome

To enable this feature, I had to go to chrome://flags/#vertical-tabs and switch from Default to Enabled. For reference, my installed version of Chrome is Version 147.0.7727.102 (Official Build) (arm64).

Wait, nothing happened. I called my brother. Turns out this flag enables the feature, but the arrangement of tabs still has to be toggled from horizontal to vertical. To do so, secondary click (right click) on a tab and select Show Tabs Vertically.

Voilà! Vertical tabs!

As you can imagine, to switch back to horizontal tabs, do a secondary click (right click) on a tab and select Show Tabs Horizontally.

Aside

Why do I say secondary click instead of right click? Because I'm an insufferable left-handed Mac user that uses mice, vertical and otherwise, and trackpads ambidextrously. So, to me, they're primary and secondary click, not left and right click.

[[:a :b]
 [:1 :2]
 [:alpha :beta]]

Now, you want to transpose them. You started with a vector of vectors. Clojure's map function is pretty amazing::

• (map f)

• (map f coll)

• (map f c1 c2)

• (map f c1 c2 c3)

• (map f c1 c2 c3 & colls)

Returns a lazy sequence consisting of the result of applying f to the set of first items of each coll, followed by applying f to the set of second items in each coll, until any one of the colls is exhausted. Any remaining items in other colls are ignored. Function f should accept number-of-colls arguments. Returns a transducer when no collection is provided.

Normally, I think of this arity of map: (map f coll). In your case, you have three collections, so you'll make use of (map f c1 c2 c3). You want to stick with vectors, so you'll use mapv, which has the same semantics.

If you ignore the outer vector, you can use mapv with vector:

(mapv vector [:a :b] [:1 :2] [:alpha :beta])
;;=> [[:a :1 :alpha]
;;    [:b :2 :beta]]

You don’t have to omit the outer vector thanks to the magic of apply, which allows you to pass a collection of arguments to a function that wants individual arguments:

(apply mapv vector [[:a :b] [:1 :2] [:alpha :beta]])
;;=> [[:a :1 :alpha]
;;    [:b :2 :beta]]

This is amazing.

With linear search, we required the elements be sorted. We didn’t require the elements be bounded. In binary search, the inputs must be bounded because we maintain two indexes or pointers that start at the beginning and end of the search space. Because we move one index half-way closer to the other each iteration, the time complexity is O(log n).

Solution

Loop recur was a nice combination for linear search. So, we’ll use it again here.

(defn binary-search
  [x xs]
  (loop [low 0
         high (dec (count xs))]
    (when (<= low high)
      (let [mid (quot (+ low high) 2)
            mid-val (xs mid)]
        (cond
          (= x mid-val) mid
          (< x mid-val) (recur low (dec mid))  ;; x in left half, scoot high index
          :else         (recur (inc mid) high) ;; x in right half, scoot low index
          )))))

Challenges

Two Are Better Than One

One of the hardest parts for me in figuring this out was that I forgot two indexes are necessary. I tried using a single index and it never converged.

Integer Division

In addition, my mid formula was wrong!

(let [low 1
      high 10]
  [(/ (+ low high) 2)      ;; 11/2
   (quot (+ low high) 2)]) ;; 5

Sometimes, / returns a clojure.lang.Ratio while quot always returns a java.lang.Long. I’ve never used quot before. In C, / truncates toward 0 when both inputs are ints, which is what we need.

Tests

(are [x xs i] (= (binary-search x xs) i)
  1 [] nil
  1 [1] 0
  1 [1 3] 0
  -1 [1 3 5 7 9] nil
  1 [1 3 5 7 9] 0
  3 [1 3 5 7 9] 1
  5 [1 3 5 7 9] 2
  7 [1 3 5 7 9] 3
  9 [1 3 5 7 9] 4
  10 [1 3 5 7 9] nil
  25 (vec (range 101)) 25
  75 (vec (range 101)) 75)

First, what do I mean by search? Find the location, or index, of a desired item in a sorted collection.

We’ll assume the collection is sorted in ascending order (1, 2, 3, … and not 10, 9, 8, …). This doesn’t actually matter for linear search. It does matter for binary search! The best case for a linear search algorithm is O(1), when the desired item is the first in the collection. The worst case is O(n), when the desired item is the last in the collection or isn’t present at all. One thing I really want in my implementation is early return.

Since most of my algorithmic training was done in C (probably C89 since variable declarations for iterators had to happen outside of for loops), I thought I’d start with while. This turned out to be very painful! I included a little test suite.

(ns sorting
  (:require [clojure.test :refer [are]]))

(defn linear-search-while
  [x xs]
  (let [i (atom 0)]
    (while
     (and (not= x (get xs @i))     ;; haven't found it yet
          (< @i (dec (count xs)))) ;; haven't gotten to the end yet
      (swap! i inc))
    (if (= x (get xs @i))          ;; find it?
      @i
      nil)))

(are [x xs i] (= (linear-search-while x xs) i)
  1 [] nil
  1 [1] 0
  1 [1 3 5 7 9] 0
  5 [1 3 5 7 9] 2
  9 [1 3 5 7 9] 4
  -1 [1 3 5 7 9] nil)

I got the stopping condition in the while loop wrong several times. First, we want to stop when we’ve found x. Second, we want to stop once we’ve exhausted the collection. I can’t think of a time I had less fun writing Clojure. Mutation, manually keeping track of an index, fiddling with a while loop. This is the worst. It does work, though! One thing that jumped out to me implementing this the use of nil instead of a sentinel value, like -1, that is common when coding in something like C.

What’s like a while loop but way better? Loop and recur! With a while loop, you say what must be true to continue. With loop recur, you say when to try another iteration and with what input. So, here’s a version that uses that.

(defn linear-search-loop-recur-cond
  [x xs]
  (loop [i 0]
    (cond
      (>= i (count xs)) nil    ;; we're at the end, not found
      (= x (nth xs i)) i       ;; found it
      :else (recur (inc i))))) ;; try again at the next spot

This is so much better!

Here’s another way to do it.

(defn linear-search-loop-recur-when
  [x xs]
  (loop [i 0]
    (when (< i (count xs))  ;; don't run off the end
      (if (= x (nth xs i))  ;; find it?
        i                   ;; found it
        (recur (inc i)))))) ;; try again at the next spot

It’s the same number of lines. I like both.

In Clojure core there’s a handy function, +. I’ll bet you know what it does:

(+ 1 2 3)
;;=> 6

Let’s introduce a handy function as we explore:

(defn value-and-type
  [& args]
  (map (juxt identity type) args))

Let’s look at the largest supported Long:

(value-and-type Long/MAX_VALUE)
;;=> ([9223372036854775807 java.lang.Long])

What happens if we exceed it?

(value-and-type (+ 1 Long/MAX_VALUE))
;;=> Execution error (ArithmeticException) at java.lang.Math/addExact (Math.java:931).
;;   long overflow

It throws!

+'

The fact that + throws on overflow is why +' exists:

(value-and-type (+' 1 Long/MAX_VALUE))
;;=> ([9223372036854775808N
;;     clojure.lang.BigInt])

Instead of overflowing, it promoted from a Long to a BigInt. In addition to +', there are -', *', inc', and dec'.

unchecked-add

Now for unchecked-add. Notice how it wraps around:

(value-and-type
 Long/MIN_VALUE
 (unchecked-add Long/MAX_VALUE 1))
;;=> ([-9223372036854775808 java.lang.Long]
;;    [-9223372036854775808 java.lang.Long])

In addition to unchecked-add, there are unchecked-subtract, unchecked-multiply, unchecked-inc, unchecked-dec, and unchecked-negate.

Summary

If you’re dealing with a Long, on overflow:

• + throws

• +' promotes to BigInt

• unchecked-add wraps around

(+ Long/MAX_VALUE 1)
;;=> Execution error (ArithmeticException) at java.lang.Math/addExact (Math.java:931).
;;   long overflow
(+' Long/MAX_VALUE 1)
;;=> 9223372036854775808N
(unchecked-add Long/MAX_VALUE 1)
;;=> -9223372036854775808

We’re going to use 2/3 throughout all our examples. We’ll use the literal 2/3 instead of (/ 2 3) because it’s more compact, and is equivalent:

(= 2/3 (/ 2 3))
;;=> true

2/3
;;=> 2/3

If you’ve programmed in most languages, you probably expected output like 0.6666667. In Clojure, we need to force that with a cast:

(float 2/3)
;;=> 0.6666667

After casting, we can see they’re not equal:

(= 2/3 (float 2/3))
;;=> false

So, what was that 2/3 we saw? Let’s inspect its type, and its value. I don’t want to write that more than once, so here’s a cool little helper function:

(defn value-and-type
  [& args]
  (map (juxt identity type) args))

Here it is in action:

(value-and-type 2/3 (float 2/3))
;;=> ([2/3 clojure.lang.Ratio]
;;    [0.6666667 java.lang.Float])

Aha! The 2/3 is a special Clojure Ratio type. What can we do with a Ratio?

Determine whether a value is one:

(ratio? 2/3)
;;=> true

(ratio? 3/3)
;;=> false

Note that rational? is a little more inclusive:

(rational? 3/3)
;;=> true

Inspect its numerator and denominator:

(numerator 2/3)
;;=> 2

(denominator 2/3)
;;=> 3

Do math operations without losing precision:

(value-and-type
 (* 2/3 3)
 (* (float 2/3) 3))
;;=> ([2N clojure.lang.BigInt]
;;    [2.0000000596046448 java.lang.Double])

That is pretty great!

You can attempt to turn a floating point number into a ratio. Beware!

(value-and-type
 (rationalize 2/3)
 (rationalize (float 2/3)))
;;=> ([2/3 clojure.lang.Ratio]
;;    [416666679084301/625000000000000
;;     clojure.lang.Ratio])

You may have guessed the following would fare better because our computers are binary, and you’d be right:

(value-and-type
 (rationalize (float 1/2))
 (rationalize (float 3/2)))
;;=> ([1/2 clojure.lang.Ratio]
;;    [3/2 clojure.lang.Ratio])

However, for even 2/3, BigInt can save the day!

(value-and-type
 (rationalize (/ 2N 3N)))
;;=> ([2/3 clojure.lang.Ratio])

2 4 6 → 22 44 66

I started with a really ugly solution:

(map
 (fn [x]
   (parse-long (clojure.string/join
                ""
                [(str x) (str x)])))
 [2 4 6])
;;=> (22 44 66)

I wanted to see how ChatGPT could improve my answer. Here’s what it came up with:

(map
 #(parse-long (format "%d%d" % %))
 [2 4 6])

This is really elegant. I’ve used format strings extensively in C, C#, F#, Clojure, and a handful of other languages I don’t know very well, but I never thought about putting the same value in a format string more than once.

;; Of course
(#(format "%d%d" %1 %2) 2 2)
;;=> "22"

;; Wow, never thought of it like this
(#(format "%d%d" %1 %1) 2)
;;=> "22"

Here’s a second solution ChatGPT came up with:

(map
 #(parse-long (str % %))
 [2 4 6])

Bravo! I felt extra silly with my clojure.string.join after seeing this. I forgot str is multi-arity with a variadic arity. I also didn’t know it had a 0-arity. Here’s the actual implementation:

(defn str
  "With no args, returns the empty string. With one arg x, returns
  x.toString().  (str nil) returns the empty string. With more than
  one arg, returns the concatenation of the str values of the args."
  {:tag String
   :added "1.0"
   :static true}
  (^String [] "")
  (^String [^Object x]
   (if (nil? x) "" (. x (toString))))
  (^String [x & ys]
     ((fn [^StringBuilder sb more]
          (if more
            (recur (. sb  (append (str (first more)))) (next more))
            (str sb)))
      (new StringBuilder (str x)) ys)))

Here’s a third solution from ChatGPT. I quite like it:

(for [n [2 4 6]]
  (parse-long (str n n)))

I almost never use for, but I should. It’s pretty amazing!

I didn’t want to be bested by the LLM, so i came up with another solution using repeat:

(map #(apply str (repeat 2 %)) [2 4 6])

One benefit of this solution is the ability to parameterize the repetitions. For example, if I wanted to repeat the digit five times instead of twice:

(let [repetitions 5]
  (map
   #(apply str (repeat repetitions %))
   [2 4 6]))
;;=> ("22222" "44444" "66666")

make it go 1 2 3, 2 3 4, 3 4 5, …

I thought, hmm, that’s a sliding window.

Here was my first thought:

(->> (range 1 4)
     (map (fn [x] [x (inc x) (inc (inc x))])))
;;=> ([1 2 3] [2 3 4] [3 4 5])

I asked if he wanted it as just one list. He asked me to show him, so I thought… I’m mapping over this and need to concatenate the lists. Wait, that’s literally mapcat:

(->> (range 1 4)
     (mapcat (fn [x] [x (inc x) (inc (inc x))])))
;;=> (1 2 3 2 3 4 3 4 5)

He said he preferred the little lists to the one big one. Good thinking.

Then I thought, can we make it shorter? I could use iterate instead of the vector literal:

(->> (range 1 4)
     (map #(take 3 (iterate inc %))))
;;=> ((1 2 3) (2 3 4) (3 4 5))

Looking at this, it’s really easy to parameterize:

(let [window-size 3
      number-of-windows 3]
  (->> (range 1 (inc number-of-windows))
       (map #(take window-size (iterate inc %)))))
;;=> ((1 2 3) (2 3 4) (3 4 5))

Then I thought, the first number in a little collection forms the basis for the next little collection. I also like this way best because it starts with a literal vector [1 2 3]:

(->> [1 2 3]
     (iterate #(map inc %))
     (take 3))
;;=> ([1 2 3] (2 3 4) (3 4 5))

It can be parameterized as well:

(let [number-of-windows 3]
  (->> [1 2 3]
       (iterate #(map inc %))
       (take number-of-windows)))
;;=> ([1 2 3] (2 3 4) (3 4 5))

After doing all that, I realize that this isn’t a sliding window at all! In a true sliding window problem, you don’t know what the elements will be. THIS is a sliding window:

(let [window-size 3
      step-size 1]
  (partition window-size step-size (range 1 (inc 5))))
;;=> ((1 2 3) (2 3 4) (3 4 5))

In any case, Clojure is awesome for this type of work.

I just learned about Calva Flares. Then I wondered, is there something built into VS Code for viewing webpages? There is! It’s called Simple Browser and was added way back in 2021!

For my use case of viewing the Clojure Cheatsheet without leaving VS Code, all I have to do is:

Open the Command Palette and select Simple Browser: Show

Type or paste in the URL

And the page appears!

Simple Browser beats out Flares by having an address bar, back, forward, reload, and open in browser controls. But, Simple Browser is a singleton.

With Flares, I can open as many as I want, and I can have a singleton in the sidebar if I add the key-value pair :sidebar-panel? true.

It’s nice to have options!

I was playing with some Clojure code in Calva for Visual Studio Code and stumbled onto a feature. In my Primary Side Bar, I have the Calva view. I noticed the Inspector previously, but it wasn’t until now that I noticed Flare.

I decided to see what it is. Here are the official docs on Flares. One of the examples shows how to display a webpage. Here’s the code snippet shown:

(tagged-literal 'flare/html {:url "https://calva.io/",
                             :title "Calva homepage"
                             :key "example"})

Here’s my editor before evaluating that form:

After evaluating, a new tab is opened with the Flare:

Now how about that Flare under Inspector in the Primary Sidebar? Add the key-value pair

:sidebar-panel? true

(tagged-literal 'flare/html {:url "https://calva.io/",
                             :title "Calva homepage"
                             :key "example"
                             :sidebar-panel? true})

There it is, on the left!

This is awesome! I can open a webview in both the sidebar and in tabs so I don’t have to leave my editor.

Here’s an example that I find helpful:

(tagged-literal 'flare/html {:url "https://clojure.org/api/cheatsheet",
                             :title "Cheatsheet"
                             :key "cheatsheet"})

Happy coding!

Customer: Thanks for seeing me. I’m really looking forward to one of your custom cars!
Salesperson: Absolutely. You can choose a 2-door or 4-door. It will be ready from the factory in 2 months.
Customer: Actually, I'd like a 6-door.

Let’s sketch out two possible responses:

• promise anything

• promise what you can

Promise Everything

Salesperson: Absolutely!
Customer: Great, when can I have it?
Salesperson: Our 2-door and 4-door cars have a lead time of 2 months. I’m sure we can do the same for a 6-door!

Promise What You Can

Salesperson: This relationship is important to us, and your business is important to us. While we do offer a high level of customization, we’ve never offered a 6-door, so I can't say with certainty how long that would take. I can check with my team. I expect it would double the timeline. Alternatively, we could deliver you a 2-door and/or a 4-door in 2 months to meet your immediate needs. If the 6-door remains important, we could revisit that after delivery.
Customer: I chose you because I heard you offer more customization than your competitors.
Salesperson: We do. I also want you to understand the tradeoffs involved with this request: a 2-door and/or 4-door in 2 months, or a 6-door with a longer, less certain timeline.
Customer: I need a car in 3 months. I’ll take a 4-door and keep in touch.

Closing

I don’t work in sales, so can you really trust my advice? I can’t say. What I can say is that the promise everything route may lead to disappointed customers and will lead to unhappy people at your company.

Is this scenario too simplistic to be useful? Even if it is, there are some lessons you can apply:

1. Know what you can reliably deliver in a given timeframe.

2. Know which changes to your offerings will make a timeframe uncertain.

3. Don’t estimate on behalf of others doing the work.

1. Only add to the top

2. Only remove from the top

To illustrate, let’s track how we get dressed using a stack. At first, the stack is empty. Let’s add a shirt, a sweater, and a coat. Our stack now looks like this:

flowchart TD
coat ~~~ sweater ~~~ shirt

Now, we want to go swimming. In real life, and in a stack, we can’t remove the shirt first since the sweater and coat are in the way. The stack we built tells us the order in which to remove the clothes: coat, sweater, shirt.

The only thing we can access is the last thing we put in. Therefore, we say that a stack is last-in, first-out (LIFO). We could also call it first-in, last-out (FILO), but nobody says that.

You can read more at https://www.geeksforgeeks.org/dsa/applications-advantages-and-disadvantages-of-stack/.

Try this next time. Tell them what you need and set up a fallback meeting far enough in the future that they can reasonably complete the task. They may start working on it right away! If not, you’ll solve it in the meeting. Win-win.

It’s a real “power move”, like the one below. I am not the Brett from the video.

I’d like to introduce you to a concept that I thought was entirely ridiculous but have since embraced: a date for a date.

A date for a date (D4D for short) is a date on which you’ll have an answer. You many not know how long a project will take, but you can probably say how long it will take you to come up with an estimate, and, consequently, a date. So, if today is April 23rd and you’re asked when a project will complete, instead of saying “I don’t know”, say, “I’ll get you a date on April 30th”.

Did I invent this term? No. I picked it up at work, and it’s fairly common in industry.