Kartones Blog

My macOS Cheatsheet

2024-01-28T14:45:00+01:00

I learn better by creating cheatsheets and summaries, so adding to my list, I recently took an old macos cheatsheet I had with a few shortcuts, and I've been improving and expanding it. I wrote it while at Eventbrite, when I had to switch from Linux to Mac, and now I'm facing a very similar scenario at Spotify; I need to build/compile iOS binaries from time to tim, so instead of having two work laptops, I made the switch.

It lives at https://blog.kartones.net/page/macos-cheatsheet/, and the content is a mix of three kinds:

Shortcuts: Both operating system and application-specific
Tips/Fixes/Tweaks
Tools: To complement my command-line tools list, GUI tools, with the restriction of being either free or open-source [1].

I must admit that, at the time of writing this post, the list of tools is pretty scarce, so I'm more than open to more suggestions. Just take into account that I'm searching for applications to either improving macos-usage in general, or development-specific.

[1] I won't pay for any software I'm only going to use at work, and I already have licenses for required tools like IntelliJ.

Debugging Typescript errors in Bazel

2024-01-21T17:05:00+01:00

Typescript errors are not always easy to debug. Add Bazel to the mix, and some errors can feel a nightmare to understand and resolve. Thankfully, there are two steps that will help a lot with triaging.

Let's imagine we have the following action, which transpiles some typescript and then runs it via NodeJS (you can find it at my Github bazel-web-template repo):

bazel run src/ts:run_d

This action calls a js_binary, to a transpiled d.mjs file, which imports from c.mjs. I have on purpose modified the import to wrongly ask for e.mjs, so when we run it, inside the Bazel execution output, we'll get the following error:

src/ts/d.mts(1,28): error TS2307: Cannot find module './e.mjs' or its corresponding type declarations.

Now let's keep imagining that we have no clue where could that error come from; We just know that something is trying to import e.mjs and fails to do so.

The first step to ease debugging, is to tell Bazel to keep the sandbox when the execution ends, so we can inspect and replicate what it ran. For that, we can use the sandbox_debug flag:

bazel run src/ts:run_d --sandbox_debug

Now, the output will be more verbose, and we will notice that, around where it outputs the error, there will be something referring to a failure/error executing a command, followed by a long execution line. In this example, calling a tsc wrapper script.

Note: I've simplified a bit the paths [1] and added some new lines for legibility.

linux-sandbox failed: error executing TsProject command 
(cd /bazel/sandbox/linux-sandbox/226/execroot/_main && \
exec env - \
 BAZEL_BINDIR=bazel-out/k8-fastbuild/bin \
 TMPDIR=/tmp \
/bazel/install/linux-sandbox -W /tmp/ -t 15 -w /dev/shm -w /tmp -w /tmp/
 bazel-execroot/_main 
 -M /bazel/execroot 
 -m /bazel/sandbox/linux-sandbox/226/_hermetic_tmp/bazel-execroot 
 -M /bazel/sandbox/linux-sandbox/226/execroot 
 -m /bazel/sandbox/linux-sandbox/226/_hermetic_tmp/bazel-working-directory 
 -M /bazel/external/aspect_rules_js 
 -m /bazel/sandbox/linux-sandbox/226/_hermetic_tmp/bazel-source-roots/0 
 -M /bazel/external/nodejs_linux_amd64 
 -m /bazel/sandbox/linux-sandbox/226/_hermetic_tmp/bazel-source-roots/1 
 -M /bazel/sandbox/linux-sandbox/226/_hermetic_tmp 
 -m /tmp -S /bazel/sandbox/linux-sandbox/226/stats.out 
 -N -D /bazel/sandbox/linux-sandbox/226/debug.out 
 -- bazel-out/k8-opt-exec/bin/external/npm_typescript/tsc.sh 
 --project tsconfig.json 
 --outDir src/ts 
 --rootDir src/ts 
 --declarationDir src/ts 
 --tsBuildInfoFile src/ts/d.tsbuildinfo)

If we re-execute in the command line that big command, we can replay very similarly what Bazel did: In our case, apparently some transpilation taking place at src/ts. But not only that, we can also alter it, by adding for example the traceResolution flag so that tsc emits more details.

Let's add it to the end, for example as --traceResolution >> out.txt:

cd /bazel/sandbox/linux-sandbox/226/execroot/_main && \
exec env - \
 BAZEL_BINDIR=bazel-out/k8-fastbuild/bin \
 TMPDIR=/tmp \
/bazel/install/linux-sandbox -W /tmp/ -t 15 -w /dev/shm -w /tmp -w /tmp/
 bazel-execroot/_main 
 -M /bazel/execroot 
 -m /bazel/sandbox/linux-sandbox/226/_hermetic_tmp/bazel-execroot 
 -M /bazel/sandbox/linux-sandbox/226/execroot 
 -m /bazel/sandbox/linux-sandbox/226/_hermetic_tmp/bazel-working-directory 
 -M /bazel/external/aspect_rules_js 
 -m /bazel/sandbox/linux-sandbox/226/_hermetic_tmp/bazel-source-roots/0 
 -M /bazel/external/nodejs_linux_amd64 
 -m /bazel/sandbox/linux-sandbox/226/_hermetic_tmp/bazel-source-roots/1 
 -M /bazel/sandbox/linux-sandbox/226/_hermetic_tmp 
 -m /tmp -S /bazel/sandbox/linux-sandbox/226/stats.out 
 -N -D /bazel/sandbox/linux-sandbox/226/debug.out 
 -- bazel-out/k8-opt-exec/bin/external/npm_typescript/tsc.sh 
 --project tsconfig.json 
 --outDir src/ts 
 --rootDir src/ts 
 --declarationDir src/ts 
 --tsBuildInfoFile src/ts/d.tsbuildinfo
 --traceResolution >> out.txt

Executing that command, we will get a very detailed tsc module resolution trace. I Highly recommended to output it to a file, as even with simple examples it is quite large!

Analysing the trace resolution, we search for e.mjs and something-something resolution...

======== Resolving module './e.mjs' 
 from '/tmp//bazel-out/k8-fastbuild/bin/src/ts/d.mts'. ========
Explicitly specified module resolution kind: 'NodeNext'.
Resolving in ESM mode with conditions 'import', 'types', 'node'.
Loading module as file / folder, 
 candidate module location '/tmp//bazel-out/k8-fastbuild/bin/src/ts/e.mjs', 
 target file types: TypeScript, JavaScript, Declaration, JSON.
File name '/tmp//bazel-out/k8-fastbuild/bin/src/ts/e.mjs' has a '.mjs' extension
 - stripping it.
File '/tmp//bazel-out/k8-fastbuild/bin/src/ts/e.mts' does not exist.
File '/tmp//bazel-out/k8-fastbuild/bin/src/ts/e.d.mts' does not exist.
File '/tmp//bazel-out/k8-fastbuild/bin/src/ts/e.mjs' does not exist.
Directory '/tmp//bazel-out/k8-fastbuild/bin/src/ts/e.mjs' does not exist, 
 skipping all lookups in it.
======== Module name './e.mjs' was not resolved. ========

And there it is, we see that the resolution comes from from [...] src/ts/d.mts. We can also see all the variants that it tried (TS/JS + type definitions), and if this was a potential package dependency, we would see it also crawl up, searching for node_modules folders and looking inside them if present.

As a summary, by enabling the sandbox persistence, and then re-playing the executed command with some extra flags, we can debug way better most Typescript errors.

Before wrapping up this post, I also want to mention some more generic debugging advices:

Checking bazel-out to see which files you have can be very helpful. Just remember to run a bazel clean if want to be certain that all files you're seeing are from your last execution, and not from past ones. Web rules tend to leave a lot of leftovers.

Many times, the source of the error is file visibility-related: You are transpiling the correct files, but then either you're not exposing them at the intended target (e.g. via data or as a dependency), or maybe your tsconfig.json is not properly set and as an example module resolution is not correctly configured, or you're missing some rootDir/rootDirs. About rootDirs, they are not that problematic in Bazel unless you use yarn/pnpm/etc. workspaces.

And finally, your mileage and preferences might vary, but in Bazel I prefer a classic approach of transpiling everything to Javascript, and then running binaries and tests against JS-only file sets, versus using ts-node, babel and similar under-the-hood transformations. Being able to check at each step if you have the proper files eases debugging and simplifies configuration a lot (specially during migrations).

[1] : Sandbox paths including the action tend to be quite long; A few times, long enough to cause issues under Windows.

My Generative AI and ML usages (as of 2023)

2023-12-30T11:30:00+01:00

As I was writing my 2023 wrap-up post, I noticed I have scattered around different posts some of the generative AI and machine learning scenarios that I'm actively using (the so-called "AI" term). It is a good idea to summarize them because my general advice from 2023 echoes what has been said a lot during the year: You should experiment and test with AI technologies.

I will focus only on technologies/APIs, but an increasing number of tools are "AI-Assisted" now, from Spotify's radio DJ to Grammarly/Language Tool.

Github Copilot

I use it as an auto-complete and smart linting helper. It allows me to switch between languages almost on the fly: JS/TS, Python, Go and Bash scripts, in my case.

Depending on the task, it is either incredibly useful or a terrible mess for more serious code generation: It took me less than 15 minutes to build some React-based animations and SCSS styling changes. On the other hand, even with the tricks of leaving open other tabs with related source files (as context), at times, Copilot struggles to understand what I want to build; even with 3 line long descriptive comments. But it is still worth a try, as it is a decent speed boost for non-complex tasks.

A related task where it is proving excellent is writing tests for your code. It probably depends on the language, but for Javascript, I keep the file containing the class under test open and write the first one or two tests. Then I just write the starting `it("blablabla"`` line, and it auto-completes it with a perfectly valid body based on the test description.

The Github Copilot Chat feature is excellent, as it removes the need to ask GPT to roleplay a developer, etc., and can give back examples directly adapted to your programming language and even your open source code files. Try it if you haven't yet. For technical questions, it became my new "Stack Overflow".

ChatGPT

Learning languages: for English, I'd instead go to specialized sites, but for Swedish, it is a fabulous quick learning tool.

It is my new Google + Wikipedia.Knowing that it might not always be correct, as long as I ask it about topics that I know exist, the information has always been correct (I still fact-check everything, just in case). Or I directly got a "up to my training data of xxxx, I don't know about that" [1].

I also use it a lot for random, trivia-like questions. My "trick" is to think if my question is available somewhere on the public internet in trusted places. I'm confident it will adequately answer all my nature, physics, and similar science questions, but beware of more niche answers. e.g. it was able to very precisely answer the question "at the end of the first Dune book, which of the characters are still alive?". But then, when asked something about the second book, it confused some facts with other volumes and hallucinated.

I've also noticed it is prone to be too gentle, both here and in Copilot-related tasks. If you tell it it was wrong, it will try very hard to please you, often inverting the previous response, even if the new outcome is false/incorrect. This fact and some basic prompting skills are still required to some extent, but I think this is a matter of pure iteration and refinement until those details get solved.

Another use is to "spice up" specific messages: e.g. we hosted an internal hackathon at work, and I used it to "cheer up" all the announcements/updates I had to write. It might tend to overuse emojis, but you can also tell it not to use any. It is the same with making a sentence or paragraph more formal or more technical.

My last usage, often API-driven, is to summarize content: From Youtube videos to complete articles and PDFs, it is excellent at interpreting data, and, via API, you can set its temperature to 0, and then it will be less creative (aka, less prone to hallucinate). The resulting summary is sometimes repetitive and dull, but digesting a 45-minute video into a three-paragraph text is a great time-saving technique.

DALL-E 3

"In the past" (as if it were a decade ago 😉), I played with DALL-E and the first versions of Stable Diffusion. A nice toy, and an incredible helper for specific tasks like assisting in Dungeon Mastering RPG sessions (although Midjourney is probably better for both player and NPC portraits), but it was either too prone to flaws and imperfections or too direct copying artist styles.

But then, Microsoft quickly added DALL-3 to Bing as soon as OpenAI announced it, and wow, the results are way better now. The images have fewer artifacts/errors (but look carefully; they still do at times!), it understands the prompts way better [2], and the quality of the images can be outstanding with fewer attempts.

As an example, with decent but far from advanced prompts, I was able to help a family member design a small poster. It took us 30 minutes of back and forth through an instant messaging app, me generating the images and sending them, her replying with the best one, and other things to tweak/change. The results were quite good; we didn't need to buy any paid clipart or ask for professional help.

I've also used the OpenAI DALL-E 3 API. There, my experience is that the results are prone to flaws (e.g., missing body parts happens a lot), so I would wait to fully automate image generation, placing an intermediate human review and approval step in the workflow for now.

Closing Words

Usefulness aside, which is coming close to many science-fiction books regarding AI assistants in concept [3], what impresses me most is the mathematical and technical complexity. LLMs are a huge multi-dimensional Markov chain (oversimplification!), statistically queried, but the text2image diffusion models feel mindblowing to me; It feels magical that we have devised a way to teach computers to convert image patterns and fragments to series of numbers, and even more incredible if we factor that they learn from shapes ("a cat") and fragments ("with tiger stripes") to colors ("orange") and drawing styles that apply to the whole image ("pixel art", "coloring book"...).

[1] Pseudo-offtopic note: ChatGPT 3.5 is now reporting to have training data until Jan 2022, so they have advanced from the original Sept 2021 mark.

[2] DALL-E 3 overrides and enriches your prompts. Often, it is good, but if you want more fine-grained control, you can force it to not re-write.

[3] Execution is still in the early stages, but I have zero doubt we'll get to a perfectly working speech-driven "user interface." Whether it is a single assistant or multiple ones, I'll leave it to futurologists.

2023 Wrap-up

2023-12-27T19:50:00+01:00

Wrapping up the year, it would be good to write a short summary.

Lots of Bazel (and other build systems), tooling, and automation. Bazel is quite complex and surprisingly rough on some edges, but I think it is a very powerful tool.

I went through (and survived) two rounds of lay-offs at work this year; technically, 3, but the middle was focused on a single product. I'm not going to dig into details or opinions, other than I'm quite unhappy with the tech industry as a whole.

Read and experimented with some of the basic foundations of LLMs, plus code generation and text and image generation (mostly ChatGPT and DALL-E 3). Despite being too brute-force based, I think LLMs and the AI topic, in general, can significantly change tech. From frequently using GitHub Copilot, to almost daily using ChatGPT [1], and helping friends and family with image-related tasks, it has already changed quite a few things in my everyday life.

Coded a decent amount of Javascript (but little Typescript) and Python (including Starlark, Bazel's flavor), and a bit of Go.

I'm ramping up on book reading (tech and non-tech, fiction and non-fiction), but it's one area I could do way more.

I also read a lot of articles, but I feel there is an information overload as of late. It takes a lot of work to keep up with everything, so I'm iterating on my sources, filtering criteria, and even time spent (e.g., reading a book instead).

Fewer courses watched, but more talks: Strange Loop, GOTO, InfoQ, and miscellaneous individual talks. But I miss the networking part of a physical conference.

I deleted my Twitter account. I don't want to be part of the crappy place that Elon is converting it into, so that party is over for me. For the moment, my only social presence is at Mastodon.

[1] I'm sure they are fully aware, but Google's biggest concern should be the fact that chat conversations with ChatGPT are a much better user experience than a search box. Of course, it's not yet useful in all scenarios, but one way or another, we'll get there.

An Entity Component System in Javascript

2023-12-21T11:50:00+01:00

Taking advantage of my Christmas holidays, one topic I had pending exploring was the Entity component system (ECS) architecture pattern. It is used primarily in video-games, but it is fascinating because of the radical departure from object inheritance, heavily leaning into object composition instead.

One of the best ways to learn is to a) read and then b) experiment, so I went and built a minimal (but representative) vanilla Javascript ECS implementation.

For the impatient, the code is available here: https://github.com/Kartones/ecs, and a basic HTML demo is here: https://kartones.net/demos/028/.

I'll remark on a few technical details, but if you want to see how everything fits, the code is compact and easy to read.

I created three systems:

InputSystem: To handle (keyboard) input. It interacts with PositionComponent components, by modifying their velocity "vectors" and/or changing positions when the Spacebar is pressed (resets all entities to new random positions).
MovementSystem: Updates PositionComponent components movement logic: update position based on velocity, or stop if at a boundary (edge)
RenderSystem: Initializes the screen (an HTML canvas) and tells RenderComponent components to render based on their PositionComponent values.

As you might have noticed, there are two components:

PositionComponent: Keeps (x,y) and a velocity vector
RenderComponent: Keeps the "sprite" data

And finally, a few managers:

EntityManager: Entities do not exist as a class; they are mere identifiers. The sole purpose of EntityManager is to generate the entity IDs and keep track of them
ComponentManager: Keeps track of all components of each entity. When a system is going through an update sweep, queries this manager to ask for all components required; e.g., the RenderSystem asks for PositionComponent and RenderComponent, ensuring that any entity has both (or will be skipped)
SystemManager: A simple list of all configured systems, plus an update() method that, surprise, triggers an update cycle on all systems

And that is mostly everything! At first, I tried to plug in Phaser for rendering graphics and handling input, but it is already an ECS! So, instead of doing weird code to access some of the systems, I discarded it and implemented a simple keyDown handler for the input and an HTML canvas for the renderer. But Phaser looks so nice and well-structured! I'll try it as a complete game engine in the future.

The origins of LEGO Mindstorms

2023-12-17T20:55:00+01:00

I recently learned that around two years after announcing the Mindstorms Robot Inventor, LEGO discontinued the Mindstorms brand in 2022.

It is sad because I've always thought LEGO Mindstorms was a great way to build robots by focusing on the creative and programming aspects while removing the complex hardware involved in a non-LEGO robot.

Reading a bit about its history, it is surprising how old it is and its origin, so here are some highlights I found interesting:

It all began with the Logo programming language, which was created in 1967! I used the the Turtle Logo Pascal library (Turtle Graphics?) to draw figures and spirals in high school.
The Technic Control Center, in 1985, was the first combination of LEGO with a programming language.
"Logo Blocks" were the predecessors of "RCX Code" and later evolutions, a purely visual program control flow language, by adding and linking visual blocks that represented loops, conditionals, sensor values, and the like.
The first LEGO Mindstorms product appeared in 1998 (the Robotics Invention System, aka "yellow brick"), but the name comes from a 1980 book, Mindstorms: Children, Computers, and Powerful Ideas.
The yellow brick was the first model commercialized to the public, but before it existed both a red brick and a grey brick:

Additional Resources:

To Mindstorms and Beyond: Evolution of a Construction Kit for Magical Machines

Content quality is suffering (as of late 2023)

2023-12-02T19:00:00+01:00

Lately, I've come to understand why GPT models avoided digesting content from later than September 2021 [1]: The amount of artificially extended written articles and videos is staggering; probably there are also more fully AI-generated cases, but I wanted to focus on human-originated cases. For me, it is more than just a matter of wasting extra time when reading because there are whole sentences or paragraphs devoid of content or repeating for the sixth time the same point with different words. The form is also of poorer quality, making it harder to understand (which fails one of the main principles of writing, to communicate something!).

Let me mention two examples:

Everybody knows that 95% of YouTube channel content nowadays is artificially extended to get extra displayed ad slots. As a specific example, a particular channel that some friends like watching seldom publishes videos shorter than 30 minutes, sometimes going as far as 90 minutes. The "short" ones are usually content that can be explained in less than 5 minutes. For the longer ones, at minimum, one could remove 1/3 of the length (interviews that get too pedantic, "in-depth reports" that iterate multiple times over each topic...). I did a test, and in a specific video (~25 mins), they mentioned one relevant term more than 20 times. This is why I experimented with building a YouTube summarizer using ChatGPT, and I use a fine-tuned variant if I check YT (which is rare).
When reading content in English, I have some leeway regarding initially wrong-looking texts, because I am not an expert in the language, so it might be a wrong interpretation. But when I read Spanish articles, I am way stricter, and it is degrading a lot outside main media sites: Half a page of buzzwords, abusing bolding text on almost every sentence (probably because not even the author can find relevant information otherwise), with sentences often cut in half, breaking the natural structure and forcing you to do extra cognitive work (maybe to give the impression of a longer text?), at times with non-sense words suspiciously looking like other more appropriate ones (LLM mistake?). And worst of all, if you read the text many times, any reasonable human being will notice something wrong.

Everybody is free to write however they want. I have friends who run their texts through ChatGPT to make them sound more formal, and I've used it to generate more cheerful messages for Slack announcements, so it is not that I'm against their use; quite the opposite [2]. But people are forgetting the basics: make your content readable and understandable, and then, if you want, make it longer. Some books could be perfectly summarized in less than a single page, so it is nothing new!

For example, I currently use Grammarly (premium) to proofread my blog posts and some emails. At work, I use LanguageTool, which serves the same function [3]. They both have browser plugins and give you spelling corrections and suggestions about tones, false friends, partial or complete sentence rewordings for clarity...

Nothing beats careful human proofreading, but if you don't have the time or desire (I often don't, and simply click publish once grammar check is ok), at least try using suitable tools to increase legibility. It would also be nice to avoid "dark patterns" in writing online content; the tools I mentioned will probably flag most of them.

[1] Although I read somewhere that this might change soon. They probably devised an accurate enough way to detect artificial content to discard.

[2] The summaries on this blog's landing page are also made by GPT (but revised by me), and I use ChatGPT very often for both general questions and as a Swedish tutor/teacher. I sincerely think that LLMs are a technical revolution in many ways.

[3] I'm considering switching to LanguageTool's premium plan, as they don't use your data for ML training. But if you are okay with that, Grammarly is excellent.

Tiny Markdown-Based Wiki

2023-10-31T18:30:00+01:00

Earlier this year, I settled on using markdown files to keep my notes around different topics. For editing and while using my computer, I am happy with Obsidian, but at times I want to quickly check something (maybe from my work computer or the phone). I could pay for the sync features of the tool, but as we're talking markdown files and a few media contents, I decided to build a simple web alternative.

TL;DR is that you can check tiny-wiki in GitHub. It is a no-frameworks, HTML 5 + CSS + Javascript glorified markdown renderer.

As a summary, it:

Fetches an items.json file containing a list of markdown files. Folders are treated as sections/subsections (supports up to one section and one subsection, so two folder levels), and the file name is treated as the Document name (and <h1> heading once rendered as HTML). The list of sections, subsections, and files is rendered at the left.
When loading a page, it fetches the markdown file, and then renders it client-side. I did some basic benchmarks, and it is faster to fetch the smaller markdown and render it, rather than pre-generating all the HTML files (at least on a decent computer or phone).
Also, when rendering a page, extracts the headings from the document and creates a navigable list at the right of the content
Supports light/dark theme (saving to localStorage)

The whole Javascript code is less than 200 lines, so straightforward to understand.

It is mentioned in the README of the repo, but I used Marked for transforming the markdowns (really fast, and very easy to extend/modify the tag renderers) and Pico.css for the styling (I love it because without needing to add any classes already makes everything pretty). Be warned that the styling is probably not perfect. I built this and did some quick experiments, but that's all.

🦇 Happy Halloween 🎃!

On multi-tasking and high WIP

2023-10-17T07:00:00+02:00

This video details why multi-tasking, or having a high work-in-progress (WIP), is ineffective. The author explains it simply and clearly, demonstrated in multiple common scenarios. And yet, it is still an endemic problem we face at work too often.

Book Review: DOOM Guy

2023-10-15T18:15:00+02:00

Review

Title: DOOM Guy: Life in First Person

Author(s): John Romero

Let's begin with the end: I won't say that I did not enjoy reading this title because I did, all in all, like the 1980 to 1996 stories. But for someone who boasts multiple times about having an extraordinary capacity to recall past events in absolute detail, it is interesting to see what the book does not speak about. e.g., all we get from the Daikatana epoch is a series of founding and management issues and mistakes and a final mea culpa.

So, I will focus on the positive things instead, of which there are also plenty.

The contents of the book are laid out, according to my ebook reader, as follows:

10% early life (until early 80s)
65% pre-id "dev life" & id Software (until 1996)
15% Ion Storm & miscellaneous (until 2001)
10% Up until 2022 (emphasis on his new DooM map packs)

This means that there is a majority of content related to Commander Keen, Wolfenstein 3D, DooM, and Quake; I am adding Daikatana to the last one, as it used the Quake & later on Quake II engines.

This book represents an excellent tale of how, with effort and dedication, you can create great things, no matter where you come from. It might not be easy, it might take some time, but it is possible. We'll read about the first PC games and the abundant problems they posed, always limited by CPU speed, but also severely handicapped by primitive graphic cards. We'll also learn about the first steps of the shareware distribution system, and why John Romero and John Carmack got a lot of money, founded id Software, and then became very wealthy in their early 20s.

I grew up living the same PC evolution and playing the very same games they were creating, from Commander Keen and Wolfenstein 3D to DooM and DooM II, and Quake is my all-time favourite videogame, so I devour any article or book that tells me more about them and how they were made. You won't be disappointed in that regard, there is plenty of internal information about building each title.

Many other geeky details are also fascinating, like why coding both DooM tools and the game itself in NeXT computers, or many of the features that Romero added to each version of the map editors, or the rare tools they would build ("Carmacizing the maps", aka compressing) and insane work they'd all put (e.g., "Michael Abrash had had to rewrite his highly optimized renderer eight times"). There are also notes of humour and funny stories here and there.

The best part of the Ion Storm era is some good lessons that Romero states as some introspection-work outcome, primarily oriented towards managing people in a company, but a few are also related with being in the videogame production industry. And, of course, the whole thing is a cautionary tale about correctly picking co-founders (and deciding their share).

The final chapters, post-Daikatana era, lose momentum and are salvageable only because of the Sigil DooM maps part.

It was a decent read, which I wasn't sure what to expect and delivered in some areas, but did not on others. Just don't expect any shocking reveal regarding what you can already read about on the internet about id Software.

Reproducible Builds

2023-09-24T21:00:00+02:00

One topic, that I incorrectly though was always happening, was that compiling always generated the exact same output (the same bytes). This is not always the case.

I know about compilation modes, optimization flags and the like, so we're not talking here about those basic scenarios. We're talking about cases where running exactly the same flags, in the same environment, and against the same source code (let's say C++), generates a binary that works exactly the same, and yet has a different checksum (and differs in some bytes).

There are two big issues with this lack of output determinism, or as it is better known, lack of reproducible builds:

Security: How can you ensure that a binary has not been tampered with, if its signature changes?
Build Caching: You will always get a cache miss if you always get a different binary

My tiny research originated from discussing with a colleague why some Windows Visual C++ builds were not cached, when there were no apparent code changes [1] and the flags were not mutating.

The first thing that he found was that indeed, Microsoft Visual C++ (MSVC) is not deterministic by default. The following article will help you achieve it: https://nikhilism.com/post/2020/windows-deterministic-builds/.

Coincidentally, I read that Golang since 1.21.0 has a perfectly reproducible build toolchain. It was explained in a blog post.

At this point, I decided to check if there were more resources, and found that there is a Reproducible Builds organization, with great general tips on what to look for in compilers, project files and the like, to achieve determinism.

And I was quite surprised to find that Java is also not deterministic by default, but with a twist: the bytecode is, but the jar files aren't. So here are some articles around that:

generic reproducibility: https://reproducible-builds.org/docs/jvm/
with Maven: https://maven.apache.org/guides/mini/guide-reproducible-builds.html
with Gradle: https://dzone.com/articles/reproducible-builds-in-java

As an extra note, these kind of non-deterministic behaviours can also happen on scripted languages like TypeScript/JavaScript, not when transpiling code, but when doing tree-shaking and/or bundling; See for example the multiple places where you can set flags to deterministic in Webpack.

[1] Build avoidance is a different topic, so let's assume that there was some reason to trigger a compilation, instead of skipping the whole step and reusing a previously compiled artifact.

Book Review: At The Heart Of Management

2023-09-13T07:50:00+02:00

Note: Free evaluation copy provided by the author.

Review

Title: At The Heart Of Management

Author: Lino F. Ciceri

Disclaimer: I'm not a manager. I've led small technical teams in the past, but not departments or even companies for which this book aims.

After the remark, I'll begin by saying that the book is interesting. I don't know how some of the themes will apply at (or collide with) different companies, but at least some chapters try to be different. There is also an overall attempt to add science, or at least use it as inspiration, to measure and orchestrate metrics, procedures and processes.

As I mentioned, this is a book about pure management: of people, of processes, of a company's mission, vision, and goals, of how to leverage research and innovation versus production, and even about ethics and behaviors, both internally and externally. But it aims to be different in a few topics, which I'll mention.

Extrapolating electromagnetic fields as market views, thermodynamics as a form of viewing impediments to change, and organizations as molecular bodies "more than the sum of their member atoms" are a few examples, sometimes even going as far as providing formulas to measure success. I don't know how applicable they are; thus, I can't judge them, but at least it is a different view, and nature is quite clever so why not try to imitate it (same as we do in areas like robotics)?

About the growth or decline of a business being always an exponential process, I am not so sure, as I've seen and know of quite a few companies that are stuck in the middle, not drowning but not going up much either, small and big, private and public ones. But my view is biased and limited, so that I can be wrong.

And the last point is that I appreciate the general theme of optimism in the book: aiming for "the common good", for "prioritizing helping others ahead of ourselves", for suggesting trying to avoid massive reductions in force/employee terminations, playing fair with the competition... All of this is admirable, but at least in my sector (tech companies), it is something that very rarely happens. I usually see companies prioritizing benefits (theirs and their investors') over anything else, employees included, as we can see from the 2022-2023 mass layoffs.

There are of course general and traditional management bits of advice, a few of them even I had heard about. Cross-domain thinking and holistic views I think are becoming more widespread, but it is good to see them remarked. And a good list of questions to ask yourself or the company executives to reflect upon and see how to steer a company.

Those previously mentioned uncommon topics are, I think, what the author means constitute the fundamental pillars of his "Timeless Management" framework. Using science and formulas and aiming to do some good, not only being selfish, in order to survive "forever".

In conclusion, it is a curious (innovative maybe?) approach to the classical company management.

Course Review: Public Speaking for Non-Native English Speakers (LinkedIn Learning)

2023-09-03T20:40:00+02:00

Course link: https://www.linkedin.com/learning/public-speaking-for-non-native-english-speakers/

It's been a while since I've done some proper public speaking, except in internal team or product area circles, but now it is always in English. And I am both not a very talkative person, and not a native English speaker.

This course of almost two hours of content felt different from most (which tend to just teach you how to speak more correct). It goes the other way around, explaining techniques to, while being yourself, being properly understood, becoming more confident, and tricks on how to pronounce English not exactly "better", but instead "more clear".

I really liked the advices it gives, and the exercise files and additional content are among the most interesting ones I've seen in English-teaching related courses.

Installing Windows 10 on the Asus ROG Ally RC71L

2023-08-26T21:30:00+02:00

The new Asus ROG Ally might devour batteries, but it is a portable powerhouse. Featuring a full Windows 10 operating system, you can install any PC game, and most will run quite nicely. I don't own one, but a friend does, and he was tinkering with backing its data up, so I asked him why not try installing Windows 10. He did, and the results are so good that he kindly sent me his notes and Powershell scripts so I could write this blog post and share a small tutorial on how to do it.

First of all, I'll address the question of why?. The answer is also quite direct (and simple): Because Windows 10 consumes way fewer resources than Windows 11. This might sound weird when, internally, Windows 10 is still Windows 10.0.xxx; it's not even 10.1, so you might think that it is a big service pack... and while there are some noticeable UI changes, it mostly feels like a bloated Win10. But one thing it does is contain a lot more official Microsoft bloatware and extra services: More apps and services to try to sell you Office 365, pure Ads, Bing search bars... Windows 10 is suitable for gaming, even more so now that Windows 7 has reached end-of-life (Win7 was perfect for a PC gaming system). You can tweak and turn off most annoyances and get it to run reasonably fast. My gaming rig feels blazing fast because it's fine-tuned only for games.

Before we go into the tutorial, in case you want to know what you're gaining and some numbers of the actual improvements, here they are:

Some games, like Dark Souls 1, went from needing 20W to deliver 60 FPS to now sustaining those 60 FPS just with 10W
Some Ryujinx titles went from not maintaining 60 FPS at 15W to stable 60 FPS at 10W
Other games, like Elden Ring, still require the performance mode, but you can notice a significant increase in FPS (or bump up the graphic settings)
Diablo IV can be played with medium settings at 15W (this one he didn't measured before, so more for informative purposes)

So we're talking about a 33% to 50% improvement, either in battery life or performance, depending on what you seek. It is a significant boost.

So, let's get on with the steps:

Pre-requisites

Backup the device's HDD contents you want to preserve. Everything will be wiped out. For example, perform a backup of the installed Windows 11 drivers (e.g., via Driver Magician)
You need a dock with USB and ethernet adapters. Mouse and keyboard are also highly recommended
Download the official Windows 11 drivers available at https://rog.asus.com/gaming-handhelds/rog-ally/rog-ally-2023/helpdesk_download/
A USB drive loaded with a Windows 10 21H1 ISO, setup with e.g. Rufus. Note the specific Windows 10 version, more details later
Disable Secure Boot in the device BIOS

Steps

With the device turned off and offline (don't yet connect the ethernet cable to the dock)

Setting up the BIOS

Connect the USB ready with the Windows 10 image
Access the BIOS by holding volume - and turning on the device. Once in the BIOS you'll notice a vibration and can let go of the button press
Navigate to boot -> secureboot and disable it
At the boot sequence section, choose the USB drive as the first boot device
Save changes & exit BIOS

Installing Windows

The device will reboot and begin the installation
At Windows setup, choose custom install and delete all device HDD partitions (100% free space, in a single empty partition)
Proceed then as usual with the setup

Installing the drivers

Drivers will be installed manually, by going to Windows Device Manager
For each unknown device, first choose to install the driver from a location, and point to the folder containing the exported drivers from the original install (via Driver Magician or a similar tool)
Some devices will still be unknown. Now install the downloaded drivers from the Asus website
Reboot the machine
Now, we must disable Windows automatic updates. Else, it might automatically upgrade you to Windows 11 and screw up this whole process. But we still need some drivers contained in Windows Update, so we need to do a single update sweep. [1]
Run these 3 scripts from an elevated (Administrator) prompt:
Win 10 Disable Automatic App Updates.bat
Win 10 Disable Automatic Windows Updates.bat
Win 10 Disable Forced Reboot After Update.bat
After running the Powershell script, you can check that updates are "company managed" instead of "automatic" in the Update settings
Now we can plug in the ethernet cable, and click on search for updates
Ensure in the list of updates that will appear that the "network adapter" additional update is selected, and check it/include it if was not selected
Proceed to install this updates list, but do not press again the update button

Installing Asus Crate

Download the software from https://www.asus.com/supportonly/armoury%20crate/helpdesk_download/
Choose the lite version, so it downloads and installs only the required components that it will auto-detect during the setup
After installing, in the personalization panel, task bar, configure the tactile keyboard to activate when there's no physical keyboard connected, or else the on-screen keyboard won't work properly
Once the setup and keyboard config are done, reboot Windows, and you're ready to install your games.

Congratulations, now you have a nice Windows 10 powered Asus ROG Ally!

Extra steps

At this point, you can remove the USB Dock if you want.

You should remove all unwanted applications and services. You can do it from the Apps section in Windows settings, or via Powershell scripts.

[1] We use the Windows 10 22H1 version image to be able to fetch updates without it installing any Windows 11 upgrade tool, at least on the first update run.

Course Review: ChatGPT Prompt Engineering for Developers (DeepLearning.AI)

2023-08-16T21:10:00+02:00

Course link: https://www.deeplearning.ai/short-courses/chatgpt-prompt-engineering-for-developers/

A brief but quite interesting course to either learn or improve basic prompt engineering skills when using ChatGPT models. During its one hour of duration, we will understand how we can guide the LLMs to provide better solutions, control their randomness, format the output, and along the way see quite a few features that might not be so obvious or well known.

Free (for now at least), with an integrated Jupyter notebook environment to reproduce the examples explained in the six lessons, and clear and concise. Totally recommended.