~/nyuma.dev

According to Wikipedia an abecedarium is "an inscription consisting of the letters of an alphabet, almost always listed in order." I was first exposed to the term thanks to the Head of Design at Notion, Randy Hunt.

A fellow Orlando native, Randy was telling me about how he added an abecedarium to his website. I thought it was a cool idea, so I decided to add one as well. Thanks Randy!

The mental model of Adonis reminds me A LOT of Laravel and Ruby on Rails, but the good thing for us is that it's in TypeScript, so I get to keep my stack(s) one language.

I adore airports. It's my favorite place to unwind besides my car. Sometimes, I get there early and just wander around, read, and even just people watch. Right now, my favorite airport is Portland International Airport. And for the things I mentioned, it's the perfect airport for that.

Never-ending, everlasting, immortal.

A dark red flower that blooms in the spring. And yes, that was the actual HEX code for the color.

A person who is pretty evenly skilled in both frontend systems and backend systems. Please, do not get caught up in the hype of the latest and greatest AI tools, y'all. Being good at things is still cool ya know.

With good full-stack fundamentals, you'll pick up any variations of these thrown at ya:

• Programming Languages
• Frameworks
• IDEs
• UI/UX Design
• Databases
• Build Tooling

If you know what a JOIN is, you can start swinging with Supabase, Sequelize, and Prisma.

If you know what the concept of arity is, Elixir, Erlang, and Haskell will be a breeze.

Hopefully, you see the essence. Now go be great.

Some books I've read and enjoyed.

• The Design of Everyday Things
• Unfu*k Yourself
• Dive Into Design Patterns
• The Psychology of Money
• How to Win Friends and Influence People
• They Both Die at the End
• Designing Data-Intensive Applications
• The Forest of Lost Souls
• Atomic Habits
• The Creative Act: A Way of Being
• Refactoring UI

Feeling or showing a lack of interest or enthusiasm.

Lately it feels as if true boredom has vanished. Social media always seems to be rushing in the moment silence appears.

I think back to a late-night drive with friends, windows cracked, smoky air swirling. To an outsider it might have looked dull—just four people circling quiet streets. Yet inside the car we sang off-key, swapped half-baked ideas, and let the night unfold at its own pace. It was anything but empty.

Here's my advice y'all: make room for boredom. Let stillness settle now and then; give your mind space to roam. Every minute doesn't have to sparkle—sometimes the quiet is brilliant on its own.

The largest community of Black and Latinx technologists in the United States.

Over the years, its been insane to see how large its gotten. From the ~200 people in 2020—when I started school to now, 15,000+ members, it's been a wild ride.

They even held a hackathon for the first time ever this year, where I got to build Seleneo, a tool that helps creators create beautiful images.

Drum Corps International; I like to call it marching band but on steroids. Rookie talent night, sleeping in gyms, traveling across the country, "see that pole? go touch it.", "front of the bus sucks", — there's a ton of lore.

Here's me and my friend Stewart from when I marched the Seattle Cascades in 2018:

Unrelated but being in the sun 12 hours a day for 3 months straight made me vantablack 😭

Elixir (pronounced "e-licks-her") 😉

I'm not like most "Elixir bros" out there. I WON'T even try to convince you to use it, nor claim it's the best language in the world. However, I will show you some of my favorite features ^.^

Actors

Elixir tackles concurrency using an actor model, where lightweight, isolated processes communicate via message passing. no shared memory headaches! this example uses spawn to create a process, send to message it, and receive to handle messages.

Think of it like a "mailbox"

Example from elixirschool

1# inside a module, you can define a `listen` function:
2defmodule Example do
3  def listen do
4    receive do
5      {:ok, "huh?"} -> IO.puts("boom. so easy. <3")
6    end
7
8    listen()
9  end
10end
11
12# to launch it, you can do:
13pid = spawn(Example, :listen, [])
14
15# then we send a message to it:
16send pid, {:ok, "huh?"}
17
18# => boom. so easy. <3

Metaprogramming

Macros let you manipulate code itself before it's compiled. they operate on the abstract syntax tree (ast), enabling powerful transformations and eliminating boilerplate.

Here's a tiny macro to automatically log function calls, showcasing elixir's prowess:

1defmodule Tracer do
2  defmacro trace(definition) do
3    # ast manipulation happens here!
4    {_def, _, [head | clauses]} = definition
5    {name, _, args} = head
6    arg_names = Enum.map(args, &Macro.to_string/1) |> Enum.join(", ")
7
8    quote do
9      # this generates the new function definition
10      def unquote(head) do
11        IO.puts("-> calling: #{unquote(name)}(#{unquote(arg_names)})")
12        result = unquote(clauses) # original function body runs here
13        IO.puts("<- result: #{inspect(result)}")
14        result # ensure original return value
15      end
16    end
17  end
18end
19
20defmodule Calculation do
21  require Tracer # make the macro available
22
23  Tracer.trace # apply the macro to the next function
24  def double(x) do
25    x * 2
26  end
27end
28
29Calculation.double(10)
30# -> calling: double(x)
31# <- result: 20
32# => 20

And this is just scratching the surface. macros enable much of elixir's expressiveness, including in libraries we know and love, like phoenix and ecto.

Did you know these things about Kansas?

• Pizza Hut was founded in Wichita
• Kansas is said to be flatter than a pancake (although I believe it's just a less than 1 topography in some areas, meaning it nearly slopes downwards)
• An abandoned nuclear missile silo outside of Wamego was once the sole source of most of the world’s LSD.
  • Oddly enough...it was being heavily distributed by two men, from Kansas...
  • This man was pardoned by Biden btw..
• Kansas sunsets are some of the most beautiful in the world

A weak recall; the inability to remember a word or phrase. I'm 1000% sure I have this.

In no particular order, here's some of my favorite work from the Japanese manga industry:

• Kuzu no Honkai
• Horimiya
• Blue Giant Supreme
• Deadman Wonderland
• Tokyo Ghoul
• GTO
• Attack on Titan
• Uzumaki
• 20th Century Boys
• Berserk
• Goodnight Punpun
• Monster
• Aku no Hana

Fun fact: I'm from Orlando, Florida.

Not so fun fact: I hate Ron DeSantis.

To over-complicate a situation through excessive or unnecessary planning, to the point that progress or enjoyment is hindered.

Exceedingly idealistic, impractical, or unrealistic.

Have you ever met someone who is just so quixotic? I first came across this word when I did DCI—the 2016 Boston Crusaders show was called "Quixotic". Keep a look out for the Synth player, she went viral back in the day for her facial expressions.

Mr. Allenson, one of my old band directors, was actually the soloist in this show which is pretty cool. He introduced me to DCI and the world of drum corps, which I'm forever grateful for.

In my eyes, Scala is what happens when someone looks at Java and says, “okay… but make it expressive.”

And y'all know I'm all about that.

Here's a real-world day-one task - stream some orders as server sent events. Here though, we're comparing a reactive Spring Data repository vs. Akka HTTP:

1- // Spring Boot (Java)
2- @RestController
3- @RequestMapping("/api/orders")
4- public class OrderController {
5-   private final OrderRepository orderRepository;
6-
7-   public OrderController(OrderRepository orderRepository) {
8-     this.orderRepository = orderRepository;
9-   }
10-
11-   @GetMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
12-   public Flux<ServerSentEvent<OrderDto>> streamOrders() {
13-     return orderRepository.findAll()
14-       .map(order -> new OrderDto(order.getId(), order.getTotal(), order.getStatus()))
15-       .map(dto -> ServerSentEvent.<OrderDto>builder().data(dto).build());
16-   }
17- }
18-
19- public interface OrderRepository extends ReactiveCrudRepository<Order, String> {}
20+
21+ // Akka HTTP (Scala) 🤩
22+ final case class OrderDto(id: String, total: BigDecimal, status: String)
23+
24+ val orderService: OrderService = new OrderServiceCaller()
25+
26+ val route: Route =
27+   path("api" / "orders" / "stream") {
28+     get {
29+       complete(
30+         orderService.all
31+           .map(o => OrderDto(o.id, o.total, o.status))
32+           .map(ServerSentEvent(_))
33+       )
34+     }
35+   }
36+ trait OrderService {
37+   def all: Source[Order, NotUsed]
38+ }
39+ class OrderServiceCaller extends OrderService {
40+   override def all: Source[Order, NotUsed] =
41+     MongoSource(orderCollection.find().toSource())
42+       .mapAsync(1)(doc => Future.successful(Order(doc.id, doc.total, doc.status)))
43+ }

1- Sinks.Many<ServerSentEvent<OrderDto>> hub = Sinks.many().multicast().onBackpressureBuffer();
2- template.convertAndSend("orderChannel", new ServerSentEvent<>(dto));
3+ val (hubSink, hubSource) =
4+   BroadcastHub.sink[ServerSentEvent[OrderDto]].preMaterialize()
5+ Source.single(ServerSentEvent(dto)) ~> hubSink

Immutable, pattern matching, and streaming composables with no frickin ceremony. The same JVM Java guys love, half the boilerplate. Better Java? You tell me lol.

The blood disorder that I have. It's a genetic condition that affects the shape of red blood cells.

Sonder [ˈsʌndər] noun

Sonder is the realization that each random passerby is living a life as vivid and complex as your own.

I absolutely love this word. It's so profound and simple at the same time. In New York, I often sit in Washington Square Park and watch people go by. I see them, but they don't see me. And I wonder what they're thinking about. It's weird to think that we all have our own stories, vices, highs, lows, and secrets. Sometimes, that fact makes my problems not feel so bad.

My favorite strains right now are:

• Runtz
• Alaskan Thunder Fuck
• Gorilla Glue (GG4)
• Apple Fritter
• Strawberry Cough

I stay loyal to my favorites, but I'm always willing to try new ones. DM me a rec. if you partake!

To me, a high-pitched prison of sound in our skulls that never shuts up and hijacks every quiet moment of lives. I've had tinnitus for years now, and it's a constant reminder of things I've lost. Wear earplugs, folks.

My favorite glorified linter. The other day, I learned something new:

1type Prettify<T> = { [K in keyof T]: T[K] } & {}
2
3type EndpointParser<S extends string> =
4  S extends `${string}?${infer Query}`
5    ? Prettify<QueryParams<Query>>
6    : {}
7
8type QueryParams<S extends string, Acc = {}> =
9  S extends `${infer Key}=${infer Value}&${infer Rest}`
10    ? QueryParams<Rest, Acc & { [K in Key]: Value }>
11    : S extends `${infer Key}=${infer Value}`
12      ? Acc & { [K in Key]: Value }
13      : Acc
14
15type OrderEndpointParams = EndpointParser<'/api/orders?id=69420&name=nyuma'>

Want to guess what the type of OrderEndpointParams is? Well, if you guessed { id: string; name: string }, you're close, but wrong.

The type of OrderEndpointParams is actually:

And that's just the tip of the iceberg. 😛

Bad things, habits, and behaviors.

It's weird because sometimes I feel like I don't have many vices. But when I really sit down and think about it, I have a lot—lol. Don't judge me.

My favorite waterfall in the entire world. Located in the Columbia River Gorge, it's a 50 minute drive from Portland, and 5 minute drive from Multnomah Falls—the most visited waterfall in Oregon.

Zod is one of the best things to happen to TypeScript. Like seriously—it's so fucking good. Check out this example of Notion-like content blocks that I wrote to show off just how great it is:

1- // Before: manual type definitions
2- type TextBlock = {
3-   type: "text";
4-   content: string;
5-   format?: "bold" | "italic" | "underline";
6- };
7-
8- type ImageBlock = {
9-   type: "image";
10-   url: string;
11-   caption?: string;
12-   width?: number;
13- };
14-
15- type ListBlock = {
16-   type: "list";
17-   items: string[];
18-   style: "bullet" | "numbered";
19- };
20
21- // Before: discriminated union with manual type inference
22- type Block = TextBlock | ImageBlock | ListBlock;
23
24+ import { z } from "zod";
25
26+ // After: define schemas with built-in validation
27+ const textBlockSchema = z.object({
28+   type: z.literal("text"),
29+   content: z.string(),
30+   format: z.enum(["bold", "italic", "underline"]).optional(),
31+ });
32+
33+ const imageBlockSchema = z.object({
34+   type: z.literal("image"),
35+   url: z.string().url(),
36+   caption: z.string().optional(),
37+   width: z.number().positive().optional(),
38+ });
39+
40+ const listBlockSchema = z.object({
41+   type: z.literal("list"),
42+   items: z.array(z.string()),
43+   style: z.enum(["bullet", "numbered"]),
44+ });
45+
46+ // After: discriminated union with automatic type inference
47+ const blockSchema = z.discriminatedUnion("type", [
48+   textBlockSchema,
49+   imageBlockSchema,
50+   listBlockSchema
51+ ]);
52
53+ // After: inferred type from schema
54+ type Block = z.infer<typeof blockSchema>;
55
56- // Before: Hardcoded validation function
57- function validateBlock(input: unknown): { valid: boolean; block?: Block; error?: string } {
58-   if (!input || typeof input !== "object") {
59-     return { valid: false, error: "Input must be an object" };
60-   }
61-
62-   if (!("type" in input)) {
63-     return { valid: false, error: "Missing 'type' property" };
64-   }
65-
66-   if (input.type === "text") {
67-     if (!("content" in input) || typeof input.content !== "string") {
68-       return { valid: false, error: "Text block missing content string" };
69-     }
70-     if (input.format && !["bold", "italic", "underline"].includes(input.format)) {
71-       return { valid: false, error: "Invalid text format" };
72-     }
73-     return { valid: true, block: input as TextBlock };
74-   }
75-
76-   if (input.type === "image") {
77-     if (!("url" in input) || typeof input.url !== "string") {
78-       return { valid: false, error: "Image block missing url string" };
79-     }
80-     return { valid: true, block: input as ImageBlock };
81-   }
82-
83-   if (input.type === "list") {
84-     return { valid: true, block: input as ListBlock };
85-   }
86-
87-   return { valid: false, error: "Unknown block type" };
88- }
89
90+ // After: Built-in validation
91+ function validateBlock(input: unknown) {
92+   return blockSchema.safeParse(input);
93+ }
94
95- // Before: Type narrowing is manual
96- const block = { type: "text", content: "Hello world" };
97- const result = validateBlock(block);
98- if (result.valid && result.block) {
99-   if (result.block.type === "text") {
100-     console.log(result.block.content);
101-   }
102- } else {
103-   console.error(result.error);
104- }
105
106+ // After: Type narrowing works automatically
107+ const block = { type: "text", content: "Hello world" };
108+ const result = validateBlock(block);
109+ if (result.success) {
110+   if (result.data.type === "text") {
111+     console.log(result.data.content);
112+   }
113+ } else {
114+   console.error(result.error.format());
115+ }