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.

If you’re reading this, I assume you’re a software engineering manager. However, the overall content applies to all projects, and the hack applies to all projects in the context of a company.

What’s the Project Management Triangle?

For the purposes of this post, the project management triangle is an illustration of the tension between scope, schedule, and resources when executing a project. Let’s isolate each of the aspects and explain what happens as they increase:

• Scope: requires a longer schedule and/or resources.

• Schedule: can accommodate more scope and/or require fewer resources.

• Resources: the scope can be expanded and/or the schedule can be shortened.

You can read more here. Said another way:

Fast, good, and cheap. Choose two.

What Do Software Engineering Managers Do?

As a software engineering manager, you’re likely tasked with delivering projects on time (schedule), at an acceptable cost (resources), with sufficient quality (scope). Your most significant cost is probably personnel.

Too Many Projects

Unfortunately, you may find your team having too many projects (or parts of a project) to work on at once. Imagine you want to work on fewer projects at a time. You should explain that the additional projects put other projects at risk due to the split attention. Sometimes, your boss or stakeholders won’t accept that. This is where the hack comes in.

The Hack

Ask for more people by explaining what the people you have are doing and what additional people will do. Now, you may not actually want more people, but you may have better success with this request. Why might this request land better? Instead of saying some work will have to wait, which they don’t want, you’re proposing a solution that is their responsibility to fulfill. Remember, this isn’t your plan A. Plan A was asking to defer some project(s). This is Plan B. This will likely have one of two outcomes.

Outcome 1

This is the best case scenario: you don’t get more people. Now, your stakeholders clearly understand the capacity limitation. So, you come to an agreement to reduce the scope. Success!

Outcome 2

This is the worst case scenario: you get more people. You should be accepting of this since managers are often meant to grow their area, not just run it.

Summary

Hopefully, your team is working on just the right amount of projects. If you have too many, ask to defer (overall scope reduction or schedule growth) to ensure better delivery of the most important ones. If that doesn’t work, try the hack: ask for more people! Good luck, engineering manager!

• 1:1s

• Sprint demos

• Team operational reviews

Perhaps the agenda is written in a Google Doc or a Confluence page. Say have your first meeting on January 3rd. The document will look something like this:

# January 3rd
- Party cleanup (10 minutes)
- Goal review (20 minutes)

Here’s the living agenda document for January 10th:

# January 3rd
- Party cleanup (10 minutes)
- Goal review (20 minutes)

# January 10th
- Printer paper (5 minutes)
- Lunch menu (15 minutes)

You may notice a pattern. Each meeting, the latest agenda gets lower on the page. By the fifth meeting or so, the scrolling becomes tedious.

Enter prepending! It looks like this:

# January 10th
- Printer paper (5 minutes)
- Lunch menu (15 minutes)

# January 3rd
- Party cleanup (10 minutes)
- Goal review (20 minutes)

Enjoy!

For the computer scientists out there, note that the most common access patterns are:

• peeking the top item, and

• pushing a new top item.

That sounds like a stack! That’s why it’s better to prepend to the agenda. It’s more efficient to access the head of a linked list, O(1), than the tail, O(n). That’s not entirely true since you can hit Command + Down on Mac or End on Windows to jump to the bottom of a document in a browser, but not everyone knows that!

Here are the elements I propose every "Hello, Production!" include:

1. Remote Code Repository

2. Automated Builds

3. Automated Tests

4. Automated Deployment

5. Logging and Alerting

Remote Code Repository

Having a remote code repository, or version control, definitely helps in a team setting. However, it also helps individuals. Something could go wrong on your machine. People with cats or small children probably know best what I’m talking about. When that happens, you’ll be glad the code exists somewhere else! A remote code repository is also a prerequisite for the next two elements. As a bonus, it enables code review by others.

Automated Builds

When your code builds on a remote machine, it increases your confidence that the build is repeatable. You might have a library installed on your local machine that isn’t specified by files in your repository. When that’s the case, remote automated builds show you the problem very quickly!

Automated Tests

Automated tests run on a remote server protect your codebase from yourself (and others) when you forget to or simply don’t feel like manually running tests. On top of that, you know that your tests are reproducible. Imagine you have a local testing database with records you forgot to seed in your remote testing database. Automated tests that run on another machine surface that kind of issue right away. I find that automated testing rewards small batch sizes, because you want the tests to pass. The smaller the changes, the easier that is. In one of my favorite articles, Yes silver bullet, Mark Seemann confirms the importance of automated testing.

Automated Deployment

The importance of automatically deploying software you run yourself (as opposed to creating binaries run by others) can’t be overstated because it plays such a significant role in increasing your deployment frequency by making every deployment less effort. See this article on DORA Metrics, or even better, read Accelerate. It’s extremely valuable to find out early that the web server can’t connect to the database, or that CORS is misconfigured.

Logging and Alerting

Logging won’t come as a surprise to those familiar with the Twelve-Factor App. The point of "Hello, Production!" is to get all of the setup done so there are no impediments to rapid iteration. Seeing evidence in logs that your changes worked builds your confidence. Perhaps you are adding authorization. It’s helpful to see approval and denial logs come through.

Having alerting set up early pays dividends. It’s best to resolve the cause of all known alerts before users arrive. It’s also good to know that alerts are making it to their intended destination before users cause alerts. One thing I’ve added to web servers is a "blow up" route to make it easy to prove that alerting is properly configured. Secure it properly so it doesn’t become a vector for a denial of service attack! You can even disable or remove it after it has served its purpose.

Conclusion

Get these five elements in place before doing the rest of the development on an app:

1. Remote Code Repository

2. Automated Builds

3. Automated Tests

4. Automated Deployment

5. Logging and Alerting

By doing so, development becomes more efficient and pleasant. On your next app, don’t delay, get to "Hello, Production!" right away!

Cream together in a stand mixer:

• 1 cup soft shortening

• 1 cup peanut butter

• 1 cup sugar

• 1 cup light brown sugar

• 2 eggs

Stir in to the creamed mixture:

• 2 ½ cups sifted flour

• 1 teaspoon baking powder

• 1 ½ teaspoons soda

• ½ teaspoons salt

Bake 10-12 minutes at 350ºF

Ingredients

• 2 cups whole milk

• 1 tablespoon chia seeds (optional for thicker chocolate, soak overnight in the milk if possible)

• ½ cup cocoa nibs

• ¼ cup brown sugar (or ¼ cup jaggery, 4 dates, 3 tablespoons maple syrup)

• 1 teaspoon vanilla extract

• ¼ teaspoon cardamom powder

• ¼ teaspoon Ceylon cinnamon powder

• 1/8 teaspoon salt

Equipment

• Measuring cups & spoons

• A high-power blender with a soup setting, like this Blendtec or Vitamix

• Mugs

Directions

1. Pour milk to the 2 cup line.

2. Add remaining ingredients.

3. Blend until smooth and hot. On my Blendtec, I run the soup setting twice.

Serves 2.

In one of my previous jobs, we managed many Oracle and SQL Server 🪟 databases. Licensing restrictions often forced us into making suboptimal choices. Here are two examples.

First, we had Oracle DB instances across the world that needed to stay in sync in a variety of arrangements. We should have purchased Oracle's Golden Gate, which is designed to "replicate, filter, and transform data from one database to another database". While it would have been exceedingly expensive, given our needs, it would have paid for itself by saving years of effort by DBAs and software engineers and would have yielded a better outcome.

Second, we had a library that ran inside of Oracle DB. We couldn't run an ephemeral Oracle DB instance locally or in CI to test against. So, the CI runner 🏃‍♂️ connected to a live staging DB server to build the library, load it into the DB, run tests, and copy back the built artifact.

DB's at My Current Company

At my current company, every relational database is PostgreSQL, except for a single MySQL database, and a pair of SQL Server databases used by a licensed product we're phasing out. The SQL Server instances are arranged so that the secondary can replace the primary without any downtime, which is excellent for keeping availability high.

The Incident

One day, the primary database slowed to a crawl! 😱 This impacted business operations and had to be resolved quickly.

Mitigation and Diagnosis

We switched to the secondary, which seemed to have better performance. After some investigation, we determined that the table indexes were highly fragmented on both, and more pronounced on the primary. We don't have expert DBAs—just some application engineers and general-purpose IT/DevOps engineers.

We decided the causes were:

1. The automated maintenance plans stopped working reliably.

2. This is a guess. After some work was done to encrypt the disks, during which the primary and secondary couldn't communicate for an extended period of time, the index fragmentation increased.

We couldn't do maintenance on the original primary as it's only possible to connect to the active DB—you knew this was coming—due to of licensing restrictions. Sigh. I thought we would have to take a maintenance window one night to rebuild the indexes.

Insight and Resolution

A colleague asked ChatGPT what our options were. They then suggested reorganizing the indexes instead of rebuilding them. Reorganizing defragments the leaf level of clustered and non-clustered indexes, improving performance without requiring extensive resources. I tried it on the secondary and it noticeably improved the performance. Success! I switched back to the primary after hours, reorganized its indexes, and saw good improvements as well. 💪 Wahoo!

More on Reorganizing

Reorganizing is lighter 🪶 on resources than rebuilding and can be done online. Rebuilding is heavier 🚜 on resources and can resolve fragmentation that reorganizing can't. In addition, rebuilding must be done offline ⛔️, unless, you guessed it - you have the right license 🪪!

Just Use PostgreSQL

This experience, coupled with ones prior, reinforced my belief that PostgreSQL 🐘 is the correct default choice when a relational database is required. PostgreSQL doesn't have to be the best at everything. The advantage it has over licensed DBs is that all the tools one would want are freely available. What about MySQL? I'll leave that as an exercise to the reader (hint: don't use it!).