Added blog post

Author: CharlieDigital

firebase.json

@@ -29,7 +29,7 @@
     ],
     "headers": [
       {
-        "source": "**/*.@(woff2|webp|jpg|png)",
+        "source": "**/*.@(woff2|webp|jpg|png|mp4)",
         "headers": [
           {
             "key": "Cache-Control",

web/components/QuasarVideo.vue

@@ -0,0 +1,24 @@
+<template>
+  <figure class="q-py-md">
+    <QVideo
+      :ratio="ratio ?? 16 / 9"
+      :src
+      :style="{ maxHeight: maxHeight }"
+      fit="scale-down"
+      class="rounded-borders"
+    />
+    <figcaption class="text-caption text-center text-italic text-grey-6">
+      <slot />
+    </figcaption>
+  </figure>
+</template>
+
+<script setup lang="ts">
+defineProps<{
+  src: string;
+  maxHeight?: string;
+  ratio?: number;
+}>();
+</script>
+
+<style scoped></style>

web/content/7-strategies-for-using-code-reviews-in-technical-interviews.md

@@ -12,7 +12,7 @@ description: Ready to incorporate code reviews into your candidate selection pro
 
 When using code reviews as an interview tool, think of it like creating a sandbox or playground for the interviewer and candidate to explore.
 
-Like burying treasures buried in the sand, the objective is to create multiple points of interest which can allow a candidate to express both their breadth and depth as you explore together.
+Like burying treasures in the sand, the objective is to create multiple points of interest which can allow a candidate to express both their breadth and depth as you explore together.  Unlike leetcode based interviews which can feel more binary in outcome, a well-designed code review can allow for better stratification of candidates by providing a greater range of responses.
 
 Try to keep it interesting by mixing and matching these 7 different strategies in your code review!
 

web/content/ais-coming-industrialization-of-coding.md

@@ -0,0 +1,73 @@
+---
+date: 2025-02-10
+author: Charles Chen
+description: AI coding assistants signal the industrialization of the programming profession where production of code changes from a bespoke craft to a high-output process; it's time to rethink the "operators" of the future.
+---
+
+# AI's Coming Industrialization of Coding
+
+[{{ $doc.author }}]{.post-author } - [{{ $doc.date }}]{.post-date}
+
+[{{ $doc.description }}]{.post-desc}
+
+The age of AI coding assistants is upon us and with this comes an *industrialization* of the profession of programming and software engineering.
+
+Despite many decades of attempts to formalize the act of programming, by and large, it is still more accurate to think of it as a craft rather than an engineering discipline.  UML, for example, was intended to be a transformative tool that formalized the craft through detailed descriptions of design, logic, and flow from which entire systems could be generated automatically.  But decades on, its practice has largely faded having fallen far from the lofty vision of replacing coding with diagraming.
+
+To this day, it is more accurate to think of each program as bespoke and hand shaped by artisans, skilled in their craft.  AI coding assistants -- even in their current fledgling state -- shift this dynamic from bespoke creation by skilled artisans to industrial operators.
+
+---
+
+In a recent article, *[The End of Programming as We Know It](https://www.oreilly.com/radar/the-end-of-programming-as-we-know-it/)*, Tim O'Reilly evokes the era of telephone operators when each call had to be manually routed from caller to callee.  This manual task was eventually entirely replaced by software and hardware to perform the routing.
+
+::quasar-image{src="/images/oreilly-operators.png" max-height="500px"}
+Screenshot from O'Reilly's op-ed; perhaps not the most accurate take on how AI copilots are going to change coding.
+::
+
+But perhaps this isn't quite the right model to consider when thinking about how AI copilots will change the craft of coding; a better analogy -- at least in the near future -- might be to consider the industrialization of a different medium: hardware fasteners.
+
+---
+
+Consider the humble, every-day hardware fastener: the nail.  Before the industrialization, if one needed fasteners, one needed a skilled blacksmith to transform raw metals into functional hardware through a process of shaping and hammering by hand.
+
+::quasar-image{src="/images/hand-crafted-nails.png" max-height="500px"}
+Prior to industrial manufacturing of fasteners, each one was hand crafted and bespoke.
+::
+
+Today, the process of creating hardware fasteners is *very different* with machines capable of mass producing nearly identical fasteners. While a skilled blacksmith may produce a few hundred fasteners a day, modern industrial machines can produce *hundreds per minute*.
+
+::quasar-video{src="https://www.youtube.com/embed/woH-m3TRakA" max-height="500px"}
+Modern day industrial manufacturing of hardware fasteners like nails occurs so fast that the process is only discernible when slowed down.
+::
+
+---
+
+The transition from the craft age to the industrial age of hardware fasteners means that it is no longer necessary to have a skilled blacksmith to produce hundreds of bespoke fasteners a day; *a modern machine can produce the same volume in a fraction of that time*.  It follows, then, that to produce fasteners in the modern age, *a hiring process selecting for skilled blacksmiths is probably the wrong choice*; the right choice is to instead hire the "operators" that:
+
+- Oversee these industrial machines,
+- Maintain them as needed,
+- And check to ensure the quality of the output
+
+It's easy to see the parallels to how AI coding copilots will change the profession of software engineering.  When an industrial machine can produce lines of code 100x or even *1000x* faster than even the most competent engineers, then it would seem that teams should consider selecting for the right "operators" of these fantastic machines!
+
+As an example, the N-Queens family of leetcode challenges are both considered "hard":
+
+::quasar-image{src="/images/n-queens-rating.png" max-height="500px"}
+Both are considered "hard" problems
+::
+
+Yet GPT makes short work of this, generating the output hundreds of times faster than even a developer could -- even if the developer already knew the algorithm and solution.
+
+::quasar-video{src="/images/n-queens-solved.mp4" max-height="600px" ratio=1.3}
+Modern day industrial manufacturing of hardware fasteners like nails occurs so fast that the process is only discernible when slowed down.
+::
+
+This huge disparity is not unlike the gap between a blacksmith and a modern industrial machine producing nails; there's simply no comparison.  Is the solution for teams to make even more convoluted and complicated puzzles?  To select for the few superhuman engineers that could even solve them? Or perhaps the right direction is to embrace this coming era of industrialized coding?
+
+Companies that wanted to enter the fastener business today surely wouldn't select for skilled blacksmiths; such companies would select for skilled operators and maintainers of the machines that produce the nails and the workers that could ensure the quality of the output.
+
+---
+
+For teams that are in the process of hiring technical talent, solely focusing on an engineer's ability to craft bespoke code is perhaps the wrong way to go about it.  In this age of AI coding copilots and the industrialization of the craft of programming, what teams should consider is selecting for a different set of skills that focus more on the safe, efficient operation of that fantastic machinery as well as ensure the quality of its output and fitness for purpose.
+
+Teams that fail to incorporate code reviews into their hiring process will be selecting for *"codesmiths"* in this coming era of industrial code production machines.

web/pages/blog.vue

@@ -6,7 +6,7 @@
     >
       <QList>
         <QItem
-          v-for="post in posts"
+          v-for="post in sortedPosts"
           class="rounded-borders q-pa-md"
           @click="navigateTo(post.path)"
           clickable
@@ -89,6 +89,14 @@ const $route = useRoute();
 
 console.log($route.path);
 
+const sortedPosts = computed(() => {
+  return posts.value?.sort((a, b) => {
+    if (a.date > b.date) return -1;
+    if (a.date < b.date) return 1;
+    return 0;
+  });
+});
+
 const { data: posts } = await useAsyncData("blog", () => queryCollection("blog").all());
 </script>