Reda Lemeden

Reda Lemeden

Indie Developer & Designer

This Week I Learned

An experiment where, for half a year, I published weekly blog posts about what I learned, in the order I’ve noted them down


This Week I Learned #1

🗓️ 2020-04-12

  • Calm technology. A term coined by PARC researcher Mark Weiser in 1995, referring to technology that does not seek to become the center of attention when we use it. It’s there when we need it, and out of sight when we don’t. More on the topic here.

  • Eggcorn. A phrase or expression that resulted from intentionally or accidentally substituting one or more words from an expression with similar-sounding words (Wikipedia). For example:

    • Praying mantis -> preying mantis.
    • Cut to the chase -> cut to the cheese.
    • Acorn -> eggcorn (duh).
  • The entire ACM Digital Library is free to access until June 30th. There’s more to COVID-19 quarantine than Netflix 😉.

This Week I Learned #2

🗓️ 2020-04-20

  • Contact tracing. A joint initiative by Apple and Google to help health organizations throughout the world slow down the spread of COVID-19. This excellent entry on NSHipster is a good place to start if you’re interested in the nitty-gritty details. The official documentation itself can be found here.

  • Last week I mentioned free access to the ACM Digital Library during COVID-19. This week I stumbled upon this list of similar offers compiled by Michael Tsai.

  • The relationship between size, stride, and alignment in the memory layout of Swift types, thanks to this excellent article by Greg Heo.

  • In Swift Combine, you can filter out nil values using .compactMap { $0 } (reference). I was using filter(_:) before but that still requires force-unwrapping the value in subsequent operations.

This Week I Learned #3

🗓️ 2020-04-26

  • The words ”esoteric” and ”niche” do not have the same connotations. I used the two interchangeably in the past, and that resulted in some really awkward sentences. Thanks anonymous reader for the tip!

  • How the layout algorithm works in SwiftUI stack views. Huge props to Adrian Zubarev for making that task easier for me. I will be sharing more about these findings, and the context that motivated them, in the near future.

  • Database normalization and normal forms, through various articles and resources, including this one. I’ve intentionally tried to stay as far as possible from databases for the past 10 years, but now I feel like I am missing out on a fundamental aspect of building server-side software.

  • After all these years, CSS is still fun.

This Week I Learned #4

🗓️ 2020-05-03

  • The Blub Paradox (thanks Kim!). Coined by Paul Graham in his 2001 essay “Beating The Averages”, this concept refers to the inability of a programmer using a hypothetical mid-level language, called Blub, to:

    • Use a lower-level language due to lack of features they are familiar with in Blub.
    • Realize that they are looking at a higher-level language when they evaluate one.

I have some reservations about this one, based on my own experience, but it’s a nice tidbit nonetheless.

  • I did some reading on flying machines this week and picked up a new word: ornithopter.

  • I almost feel ashamed for not knowing this one until this week: deuteragonist and tritagonist.

  • This answer by Dave Abrahams to a Quora question about the most important things involved in delivering a great software library. If I had to pick only one, that would be “rigorously document“.

  • The .org TLD is saved!

This Week I Learned #5

🗓️ 2020-05-10

  • 自粛じしゅくつか (jishuku-tsukare). An expression that’s gaining momentum right now in Japanese media, meaning getting tired of voluntary confinement.

  • Visual explanations go a long way in demystifying tricky topics such as [floating numbers](Floating Point Visually Explained) and regular expressions.

  • JavaScript frameworks are costly, argues this well-researched piece by Tim Kadlec. One would think that performance tends to get better over time in technology, but that doesn’t seem to be the case in JS-land.

  • I picked up some LaTeX this week for writing mathematical notations and this cheatsheet came in quite handy.

This Week I Learned #6

🗓️ 2020-05-17

  • How the MissingNo. sprite is rendered in Pokémon. If you are into retro games and programming, I highly recommend this channel.

  • The Scunthorpe problem is, according to Wikipedia, “the unintentional blocking of websites, e-mails, forum posts or search results by a spam filter or search engine because their text contains a string of letters that appear to have an obscene or otherwise unacceptable meaning.” Via Scunthorpe Sans.

  • How HTTP/3 and QUIC work. I hadn’t heard about QUIC until earlier this week and watching this talk by Daniel Stenberg was a perfect way to catch up. Thanks Alaa for the tip!

  • Global variables in Swift are lazy—it’s in the docs even. I don’t know how I ended up with the assumption that they are eagerly evaluated (thanks again, Kim!).

This Week I Learned #7

🗓️ 2020-05-24

  • Concern trolls. I had never heard this expression before until I read about it in the context of US politics. It refers to a person who, in order to be accepted, pretends to agree with a group of people about a given topic, only to constantly seek to sow doubt and confusion among their ranks, disguising their ruse as “concerns”.

  • If there is something that can be exploited, you can rest assured that unscrupulous Web sites will exploit it. The latest episode is port scanning through WebSockets. I didn’t even know this was possible, and I am kind of bummed that browsers keep encroaching more and more on operating system territory. I mean, who in their right mind wants a random Web site to control their device vibration?

  • Boolean blindness and why booleans are not always the right choice in the context of data modeling. Via Matt Diephouse’s “You Might Not Want a Boolean”.

This Week I Learned #8

🗓️ 2020-05-31

  • The difference between input and output randomness in game design (video). The gist of it that randomness that occurs before a player action is referred to as input randomness—a prominent example being procedural level generation—while randomness that occurs after user action is called output randomness, such as the case with loot boxes and success rates.

  • I’ve been using Markdown for years, but I never realized you could add image titles like this: ![Alt](/url/to/image.jpg "A title"). Granted, I usually avoid using the title attribute for the reasons outlined here.

  • Core Data became a lot easier to work with since the last time I used it, which was before NSPersistentContainer for those familiar with the framework. That said, it still feels clunky by today’s standards—can we have the Codable of data persistence already?

This Week I Learned #9

🗓️ 2020-06-07

  • The current chain of events unfolding across the US made me realize how much work still needs to be done in a country that prides itself on equality and justice. #BLM

  • Tools for better thinking (link). A nifty website with an assortment of techniques and frameworks to help with decision making and problem solving. The Dropbox Design blog has more on some of these models.

  • Circle packing (Wikipedia). I was introduced to the concept of packing density in business school as part of a product design and packaging workshop, but I never had the chance to take a look at the math behind it. Geometry is beautiful.

  • The UI on the Crew Dragon was built using Web technology running on Chromium, according to this AMA.

  • I’ve used Swift key paths here and there, but I never explored the lesser known parts of this API. This week I picked up AnyKeyPath and PartialKeyPath<Root> and used them for a server-side project I am working on (link).

  • Android phones seem to be crashing when using a particular image as a wallpaper (link). According to this Twitter thread, the issue happens during color space conversion, where the formula used to create a pixel lightness matrix rounds the color values up, resulting in a RGB sum greater than 255. This in turn causes an out-of-bounds exception that keeps happening every time the system UI process restarts. As a side note, this formula is formally called sRGB Luma (Rec. 709). I’ve written more about it and other color lightness topics here.

This Week I Learned #10

🗓️ 2020-06-14

  • Spontaneous cognition and how random thoughts emerge from the brain (link).

  • IPFS, a peer-to-peer protocol powering a number of decentralized Internet projects. I knew about Solid and Dat, but never heard about this one, which seems to be even more popular within the decentralized Web community according to this survey.

  • NGINX has now a preview release with HTTP/3 over QUIC support. The announcement blog post has a good overview of the technology and how it’s different from its predecessors.

  • The Fail publisher in Swift Combine. Similar to its sibling Just, it competes immediately, but with a failure instead of a value—useful for testing and debugging the unhappy paths in your app (link).

  • Writing tests is vital for maintaining a healthy, and functional, codebase. This is less of a revelation and more of a reminder: a test I wrote while debugging a database query issue helped me discover and fix two unrelated bugs.

This Week I Learned #11

🗓️ 2020-06-21

  • Why books—and other traditional methods of knowledge transmission—don’t always work (link). It is no coincidence that this essay resonated with me a great deal—learning is a topic that’s very near and dear to my heart. Most of the skills I use today to do my job are self-taught, and learning languages was and is still a big passion of mine. Andy expands on the idea that without additional metacognitive skills, reading books is insufficient to acquire knowledge and understanding due to the flawed transmissionist model that they are implicitly based on. And come to think of it, this very experiment is a metacognitive tool that helps me remember the new concepts, ideas, and techniques that I learned.

    • As an aside, I’ve had the pleasure to interact with Andy Matuschak, the author of this essay, when he used to work on UIKit at Apple. He was kind, helpful, and profusely generous with insider knowledge that helped me improve some of the articles I wrote on thoughtbot’s blog. I stumbled across his website this week and I am really looking forward to more of his work in the field of learning and cognition.
  • Speaking of reading, I picked up the latest work of Shūzō Oshimi, わだち (chi-no-wadachi, Trail of Blood, 2017–ongoing), and I wasn’t disappointed. What starts out as a run-of-the-mill slice of life quickly spirals into an unsettling psychological thriller with some of the most nail-biting moments I’ve experienced in the format. If this sounds like something you would enjoy, give it a shot (日本語, English).

This Week I Learned #12

🗓️ 2020-06-30

All of the notes I’ve taken this week are related to WWDC 2020, Apple’s annual developer conference.

This Week I Learned #13

🗓️ 2020-07-05

  • I am a bit late to the r/covidcookery party, but this weekend I baked my first cake ever! An okay-looking, totally edible pound cake. There’s definitely a lot of room for improvement, but the sense of achievement when I took it out of the oven and it wasn’t a complete mess is quite the feeling. Thanks Alaa for the hands-on tips!

  • It took quaternions 150 years after their discovery by Williams Rowan Hamilton to find practical uses such as 3D computer graphics and robotics. Immediate applicability is never the primary goal of mathematical research (article via Hacker News).

  • Gemini is a budding client-server protocol aiming to offer a bloat-free alternative to the HTTP Web. It uses a Markdown-inspired document format and completely forgoes client-side scripting and styling (source).

  • I saw a PC ad on Japanese TV that ended with the Intel Inside slogan:「インテル入ってる」(interu-haitteru). Pretty clever for a marketing localization, right? Well, as it turns out, the perfectly-rhyming Japanese slogan came first (!) and served as inspiration for the English version, according to Susumu Furukawa, the president of Microsoft Japan between 1986 and 1992 (source).

  • I totally missed this initially, but it’s possible starting iOS 14 to customize the navigation bar title in SwiftUI (link).

This Week I Learned #14

🗓️ 2020-07-13

  • Lambertian surfaces and their photometric properties, through this stunning interactive guide by Bartosz Ciechanowski.

    • If you had asked me ten years ago about how Wikipedia or Wolfram Alpha would look in 2020, I’d have pictured something along the lines of Bartosz’s work. Yet, we’re absolutely nowhere near that. One can’t help but wonder if we have been focusing on the right things all these years.
  • I learnt quite a bit from this exploratory piece by Mattt about how core concepts from the Semantic Web can be used to make the code we write semantically richer, unlocking new authoring, distribution, and reuse possibilities in the process.

  • How the new matchGeometryEffect works in SwiftUI. This new API enables synchronizing view animations and transitions regardless of their place in the hierarchy. It’s quite powerful and will make some previously labor-intensive effects much easier to achieve (link 1, link 2).

This Week I Learned #15

🗓️ 2020-07-19

  • Understanding any topic in greater depth requires honesty, integrity, and patience. Thinking hard about the problem space and seeking first-hand experience also yields far deeper understanding than contenting oneself with the syntheses of others (link).

  • Beta invites to OpenAI’s API, powered by the new GPT-3 (paper), are starting to go out and some of the demos are generating a lot of buzz at the moment. This was the article that brought my attention to this.

  • How to properly use services in Vapor 4. I am still not fond of the amount of work involved, but it’s an effective way to extend the built-in capabilities of the default types.

  • How to use HTMLElement to build a custom DOM element that encapsulates structure, styling, and interactions (link).

  • How the isSource and properties arguments in SwiftUI’s matchedGeometryEffect work (link).

This Week I Learned #16

🗓️ 2020-07-26

  • This week I picked up aws-sdk-swift with the goal of integrating with SES, Amazon’s cloud email service. After some initial struggle figuring out which API version to use and how, I managed to send emails from a server-side Swift app I am currently working on.

  • Some valuable lessons about S3, AWS billing, and CDNs by Chris Short (link).

  • SwiftUI’s new Menu component is now available on iOS 14 as of Beta 3. I suspect contextual menus to gain more traction on iOS and I am happy to see them join a growing list of SwiftUI components.

This Week I Learned #17

🗓️ 2020-08-03

  • The coastline paradox refers to the phenomenon where the fractal nature of coastlines causes their length estimates to vary widely depending on the scale of the ruler-used. This length tends towards infinity as the measurement unit gets smaller and smaller, going against the logical expectation when measuring a finite distance (via Marc Edwards).

  • The proportionality bias refers to our tendency to assume that major events have major causes. While it’s often cited as a likely reason people believe in conspiracy theories, it’s also why programmers spend hours debugging a problem, probing every nook and cranny, only to find out that the cause is much more trivial than what was anticipated.

  • In 3D graphics software, namely Blender, a *shadow catcher- is a completely transparent material that “catches” and renders the shadows of other objects in the scene—useful when exporting 3D renders for further 2D composition and editing. When using the Cycles renderer in Blender, this is as easy as ticking a checkbox. In EEVEE, Blender 2.8’s new rendering engine, it requires using a custom shader to obtain a similar effect.

  • I went trough the first half of the Tour of Rust guide with the intention of getting more familiar with its syntax and memory management APIs. Beside the relationship between ownership and mutability, many of the concepts introduced in what I’ve seen so far felt quite similar to their Swift counterparts.

This Week I Learned #18

🗓️ 2020-08-09

  • Polybius is an urban legend from the early 2000s around an arcade game experiment that was allegedly run in the 80s by the US government in Portland, Oregon. According to the legend, the game was extremely addictive and caused several psychoactive effect on the players. Shortly after its supposed release, it is said that all Polybius arcade machines have disappeared without a trace.

    • Most of this sounds ludicrous, but it never hurts to indulge in an urban legend or two, especially if it involves video games.
  • The Zeigarnik Effect refers to people’s tendency to remember incomplete tasks better than successful ones (via Laws of UX). No wonder I have a constant sense of guilt over my abandoned side projects.

  • Writing both the client-side app and the server-side API in Swift has some pretty significant benefits. In addition to sharing a lot of business logic, this approach reduces the impact of context switching when developing a new end-to-end feature. Writing the entire stack in the same language, using the same IDE, in the same workspace is a godsend.

This Week I Learned #19

🗓️ 2020-08-16

  • Esprit de l’escalier, “the staircase spirit”, is a French expression used in English to describe the frequent occurrence of coming up with the perfect reply only after leaving the premises of the argument or debate.

  • What connection pooling means in the context of server-side applications and how it’s implemented and used in various Swift frameworks (link).

  • Orthogonality in programming refers to the ability to use a limited set of constructs in a limited number of combinations, where changing one part doesn’t affect the others (via this article).

  • Speaking of orthogonality, or extreme lack thereof, the Web front-end ecosystem is as fragmented, poorly documented, and messy as ever. With every new wave of build tools, frameworks, and dependency managers comes an additional layer of compatibility issues and gotchas. Sometimes writing few extra lines of code for one less dependency isn’t all that bad.

This Week I Learned #20

🗓️ 2020-08-24

  • How to use mdx and mdx-deck to create interactive slide decks. It’s essentially a mashup of Markdown and React that generates highly customizable HTML slides that can be deployed as is or exported as a PDF document. I usually scuff at the idea of using Web-based presentation tools, but this stack lends itself particularly well for the Web-dev related material I am currently working on.

  • I never paid close attention to how bitwise operations and bit shifting exactly work, but this article by Donny Wals prompted me to stop procrastinating and go over the official Swift guide on the topic.

  • I managed to use the new redacted(reason:) modifier in SwiftUI and remove the custom view I used for the purpose of displaying placeholders while the content loads. Happy to see utility APIs like these make their way to the framework.

This Week I Learned #21

🗓️ 2020-08-31

  • What Write-Ahead Logging (WAL) in SQLite is a and how it can be used in the context of Core Data (link).

  • The rule of least power is a programming principle that prescribes the use of the least powerful programming language capable of solving the problem at hand (wikipedia). In the same vein, the principle of least privilege refers to the design principle where each abstraction layer in a computer program should only be able to access the resources it needs to do its job (wikipedia).

This Week I Learned #22

🗓️ 2020-09-07

  • I picked up several new Japanese expressions this week, but this one stood out to me: ()言葉(ことば)()言葉(ことば). An English equivalent would be tit for tat. The origin of this expression is likely related to the expression 喧嘩(けんか)()る, to “sell” a fight, meaning to provoke it. In this transactional analogy, “buying” the fight is analogous to retaliating.

  • A good refresher on password storage best practices: We Didn’t Encrypt Your Password, We Hashed It. I knew about using salts (and peppers!) to secure password storage, but I have yet to add these extra security measures to the server-side app I am currently working on.

  • I learned how to do SQL joins with their different flavors. I always procrastinated on learning SQL, for various reasons, but I got to a point where I had to choose between taking a step back and doing things right, or hacking my way through the feature I was working on without understanding the performance implications of the queries used.

This Week I Learned #23

🗓️ 2020-09-15

  • Parochialism is a term used to describe situations where solutions to small, local problems come with no consideration of their effect on the whole (wikipedia).

  • Daiji (大字) are alternative kanji numerals used on bank notes in China and Japan to reduce the risk of forgery. This is necessary given that many everyday kanji numerals can be turned into other numerals with few additional strokes (link).

  • Brenda Storer reminded me of the ch unit in CSS and how it can be effectively used in type-centric layouts. Thanks Brenda!

  • I recently hit a wall with protocols in Swift; they can only be conformed to once, which presents a challenge in certain use cases. For instance, when creating reusable, model-agnostic views using protocols, every business logic model is limited to a single conformance. This constraint is problematic when the model can have more than one data mapping, depending on the context, screen, etc. To remedy this, I replaced protocols with value types, or “protocol witnesses”, allowing me to create several data mappings between a given model and the view.

This Week I Learned #24

🗓️ 2020-09-20

  • Moment.js is now in maintenance mode. I have used it on several occasions in the past, without realizing that it has fallen out of favor as of late. I looked for an alternative to display relative dates on the microblog page and settled up on the more lightweight date-fns.

  • This week I have been grappling with an annoying SwiftUI bug that only affects simulator builds. The stack trace isn’t of much help and no amount of view hierarchy tweaks got rid of it entirely. Initially I was under the impression that either my code or one of my external dependencies were doing something horribly wrong, but this post from Peter Steinberger made me realize that it is a rather widespread issue. For the time being, I am commenting out the code branch that triggers the issue when running the app on the simulator.

  • I refreshed my knowledge on variable fonts in CSS and the considerations to make when working with them thanks to this wonderful guest lecture by Chad Mazzola. Hope my students enjoyed it as much as I did!

This Week I Learned #25

🗓️ 2020-09-29

  • The term ”bleeding edge” was first coined in the early 80s as a more extreme version of “cutting-edge” or “leading-edge” (Source). You know that things are serious when blood is involved.

  • Idempotence in the context of REST APIs refers to the ability to repeatedly call an endpoint without producing additional side effects on the server other than the ones produced by the first call (Wikipedia, link). It’s typical for REST endpoints to be idempotent save for the ones using the POST HTTP method.

This Week I Learned #26

🗓️ 2020-10-06

  • Two concepts I learned about this week came straight from Ted Lasso, the Apple TV+ series. The first is the official name of the phenomenon where repeating a word enough causes it to temporarily lose its meaning: *semantic satiation- (wiki). The second is the german word Schadenfreude, which means drawing pleasure from the pain that besets others. Coincidentally, it’s also trending on Merriam-Webster for an entirely different reason.

  • From reading One Piece I picked up a new Japanese expression: 臭いものに蓋 (kusai-mono-ni-futa). Its literal meaning is “to cover what stinks”. Its figurative meaning is to look the other way or hush up a problem (link).

  • A snowclone is an expression template where replacing one or two words produces an infinite number of variants. Example: X is the new Y. There is even a website that tracks them!

This Week I Learned #27

🗓️ 2020-10-13

  • 尻拭い (shiri-nugui). The literal meaning is “ass-wiping”, but the figurative meaning is to clean up somebody’s else mess.

  • 自業自得 (jigou-jitoku): Reap what you sow.

  • I have used SwiftUI’s LazyVGrid for the first time and I am quite pleased with the result. The API was easy to figure out, despite the lack of documentation, and the performance has been decent for my particular use case. I even managed to achieve an interesting visual effect by wrapping two lazy grids in a ZStack.

  • In UI programming, working with states other than the happy path represents at least two thirds of the work. In particular, the transitions between success, error, and loading states take an inordinate amount of time to get right.

This Week I Learned #28

🗓️ 2020-10-20

  • Prima facie, a Latin expression that means on the first impression or on the face of it (wiki, via this article on Daring Fireball).

  • This weekend I wrote a tiny Express.js app to use as a POSSE server for this website. After learning the hard way about the difference between CMD and RUN in a Dockerfile, I ran into an issue with my nginx-proxy and Let’s Encrypt setup on the VPS. After several hours of poking around, I found an outdated version of this Docker image to be the culprit, which will make me think twice before version-locking security dependencies like this one.

  • The assignment operator := in Python is called the walrus operator (via this episode of the Lex Fridman podcast). Simply brilliant; I mean, look at it!

This Week I Learned #29

🗓️ 2020-10-27

  • In a typical RTFM case, I just learned that localizedDescription was not defined in LocalizedError like I’ve been incorrectly assuming.

  • To make up for that, I am now more familiar with the properties that come with the LocalizedError protocol and how to use each to improve error handling in both server and client apps.

  • Speaking of errors, dealing with synchronous errors using do/catch alongside asynchronous ones in SwiftNIO requires taking some special API design considerations. It’s easy to fall into the trap of writing code that can both throw and return futures, thus requiring two forms of incompatible error handling. One possible, and rather straightforward, solution is to turn synchronous throws into failed futures that can be easily used in an async pipeline.

  • I gave the official Mongo driver for Swift a try and I am quite pleased with it. On the API-front, I have some quibbles with how it handles decoding errors for Decodable types, but I can live with those for now.

    • I have mixed feelings about Mongo itself, but I appreciate not having to worry about schemas and migrations for every server app I am deploying. For certain micro-projects, the benefits of NoSQL far outweigh the drawbacks.

This Week I Learned #30

🗓️ 2020-11-03

  • ()()でも (ze-ga-hi-demo). To do something at any cost. No matter what. Similar to 是非とも. On its own, 是非 (zehi) refers to the pros (是) and cons (非) of something.

  • The Streisand effect refers to the phenomenon that happens when the act of trying to hide or censor certain information ends up having the opposite effect of spreading it even further (wiki).

  • I needed to migrate a few lines of code from CryptoKit in a Mac app to Swift Crypto in a server-side service, and was pleasantly surprised when I realized that the two frameworks expose the same APIs, making for a hassle-free migration and a happy Swift developer.

  • Is it only me or executable Swift packages can’t be tested in SPM and Xcode? I haven’t tried in the CLI but I was getting all sorts of cryptic errors that only went away when I moved the code to a standalone library. I need to take a closer look into this to get a more complete understanding of what’s going on.

  • While trying to follow along the Swift Concurrency Roadmap, I came across the concept of the actor model which, beside yielding some noteworthy image results in DuckDuckGo, seems to be a tried-and-true computation concurrency model that draws some inspiration from the laws of physics. I have a ton more reading to do to actually understand any of this, but I’m looking forward to that.

This Week I Learned #31

🗓️ 2020-11-11

  • This tweet by Serenity Caldwell taught me a new word: chiasmus. It’s a literary device in which two or more clauses use similar words but in a reversed structure. While reading about it, I also came across another similar concept, antimetabole, which seems to be similar but with a subtle difference that I can’t quite wrap my head around (link).

  • Every developer comes across a time zone bug some time during their career; and it was my turn last week. While using Swift’s Foundation, I forgot to set the timezone property on the formatter that parses a string into a date, which resulted in different dates in the client and server apps. The fix was quite straightforward:

    formatter.timeZone = TimeZone(identifier: "UTC")
  • I finally decided to sit down and fix the myriad Core Data issues that plagued my iOS app. I learned a ton regarding some APIs that I wasn’t familiar with, including perform/performAndWait(link), background contexts, and batch deletions. I recommend checking out Antoine’s blog to learn more about some of these topics.

This Week I Learned #32

🗓️ 2020-11-17

  • I learned a good deal about integrating Vapor apps with MeiliSearch, a lightweight alternative to ElasticSearch written in Rust. The bulk of the work consisted in writing a NIO-compatible API wrapper for MeiliSearch, since the official one wasn’t meant to be used in server environments. I briefly considered using ElasticSearch, but I like the sound of a more focused library with a smaller footprint.

  • GPT-2, the open-source predecessor to GPT-3, is perfectly capable of generating images when trained on pixel sequences (paper). Here is a project that uses it to generate thousands of Pokémon-like pixel illustrations. I am tempted to give this a go and see what fun applications I can come up with.