Morcilla de Verano Recipe (Eggplant Dip)

2025-08-21T00:00:00+00:00

Morcilla de Verano</h1>
The name of this dish from the Murcia region of Spain translates to "summer morcilla", named after its resemblance to the filling of a type of blood sausage called morcilla. In spite of its name, this is a meat-free recipe, made by stewing down eggplant into a deliciously savory dip with a soft spreadable texture.

Ingredients</h1>

olive oil</li>
1 onion (chopped small)</li>
2 medium eggplants (cubed)</li>
2 tbsp pine nuts (since they're expensive, can sub for chopped walnuts or other nuts)</li>
~100ml white wine</li>
salt, black pepper, oregano (optionally, to taste: cinnamon, paprika, maybe cumin)</li> </ul>
Recipe</h1>

In a pan, toast the pine nuts until fragrant. Reserve.</li>
Heat up olive oil in a pan and add the onion, sautée over medium-low (10~15m).</li>
Meanwhile, precook the cubed eggplant by microwaving it for a few minutes until soft.</li>
Add the eggplant and pine nuts to the pan, season with salt, oregano, black pepper and deglaze with white wine.</li>
Once alcohol has evaporated, cover and cook on low for ~15-30m, until you like the texture, the longer you cook it, the more it will break down and become jammy.</li>
Taste and adjust seasoning to taste (can add more oregano or spices at this point).</li>
Optionally drizzle with more olive oil and garnish with more nuts. Serve with bread.</li> </ol>

A little XOR trick to micro-optimize some integer data structures

2025-08-13T00:00:00+00:00

Motivating example</h1>
Say you want to write an integer hash-set implementation in C. You might start like this:
/* a hash-set implemented with a flat open-addressed array with linear probing */ struct set { int *entries; size_t N; }; void set_init(struct set *set, size_t initial) { /* make sure N is a power of 2, with enough capacity to minimize collisions */ for (set->N = 8; set->N < initial * 2; set->N *= 2) ; set->entries = calloc(set->N, sizeof *set->entries); } unsigned inthash(unsigned x) { ... } bool set_contains(struct set *set, int x) { int h = inthash(x) & (set->N - 1), i = h; do { ----> if (entry i is empty) <---- return 0; else if (set->entries[i] == x) return 1; i = (i + 1) & (set->N - 1); } while (i != h); /* set is full, looped around */ return 0; } void _set_grow(struct set *set) { ... } // omitted for brevity void set_put(struct set *set, int x) { int h = inthash(x) & (set->N - 1), i = h; do { ----> if (entry i is empty) <---- set->entries[i] = x; else if (set->entries[i] == x) return; /* nothing to do */ i = (i + 1) & (set->N - 1); } while (i != h); /* full set, looped around */ _set_grow(set); set_put(set, x); } </code></pre> The problem is, if every array item can hold a key, how do you mark an entry as empty? There's two ways you can go about this: Out-of-band signaling, so you keep a separate array bool *hasentry</code> also of size N, which for every index stores whether the corresponding entry is used or empty. Initialized to zeroes and updated when new entries are added in set_put</code>. Instead of 1 byte per entry with a bool array, you can be more efficient using a bit array. This is the generalized approach that is useful if the values the set is storing are truly arbitrary.</li> In-band signaling, meaning you reserve a special sentinel value to represent an empty entry. This places a restriction in the values your set can hold, but very often this is fine. This technique is for this use case.</li> </ul> So the easy case is if your sentinel value is zero, then it's a matter of changing if (entry i is empty) </code></pre> into if (!set->entries[i]) </code></pre> and adding a check like void set_put(struct set *set, int x) { assert(x != 0 && "illegal value"); ... } </code></pre> Note that in set_init</code> (and _set_grow</code>), the use of calloc</code> already zeroes the whole array, marking it initially as all empty, exactly as we want. But in practice, very often the integers you might wanna store in the set are not arbitrary (so you can use the sentinel technique), but zero is a value you would like to be able to store, thus not a good sentinel. In this case you have to fallback to a non-zero sentinel, for example #define _SET_EMPTY INT_MIN void set_init(struct set *set, size_t initial) { ... set->entries = malloc(set->N); for (int i = 0; i < set->N; ++i) set->entries[i] = _SET_EMPTY; } bool set_contains(struct set *set, int x) { ... if (set->entries[i] == _SET_EMPTY) return 0; ... } void _set_grow(struct set *set) { int *old_entries = set->entries; size_t old_N = set->N; set->entries = malloc(set->N *= 2); for (int i = 0; i < set->N; ++i) set->entries[i] = _SET_EMPTY; ... } void set_put(struct set *set, int x) { assert(x != _SET_EMPTY && "illegal value"); ... if (set->entries[i] == _SET_EMPTY) set->entries[i] = x; ... } </code></pre> This works fine, but we lose the nicety of calloc</code>. My trick combines the benefits of the zero-sentinel (initialization for free) and an arbitrary sentinel by simply storing the value XORed with the sentinel. We keep the calloc</code>s for zero initialization</li> if (entry i is empty)</code> becomes if (!set->entries[i])</code></li> We XOR the value with the sentinel before storing it and when getting it out of an entry:</li> </ul> Thus: bool set_contains(struct set *set, int x) { int h = inthash(x) & (set->N - 1), i = h; do { if (!set->entries[i]) return 0; else if ((set->entries[i] ^ _SET_EMPTY) == x) // <-------- return 1; i = (i + 1) & (set->N - 1); } while (i != h); /* set is full, looped around */ return 0; } void set_put(struct set *set, int x) { int h = inthash(x) & (set->N - 1), i = h; assert(x != _SET_EMPTY && "illegal value"); do { if (!set->entries[i]) set->entries[i] = x ^ _SET_EMPTY; // <-------- else if ((set->entries[i] ^ _SET_EMPTY) == x) // <------- return; /* nothing to do */ i = (i + 1) & (set->N - 1); } while (i != h); /* full set, looped around */ _set_grow(set); set_put(set, x); } </code></pre> This works because of the mathematical properties of bitwise XOR: x^y == 0</code> if and only if x == y</code>,</li> If x^y = z</code> then z^y = x</code> and x^z = y</code> (XOR is reversible)</li> </ul> In situations where calloc</code> is more efficient than malloc</code> + manual initialization, this is a potentially more efficient solution, especially if the size of your set is unpredictable and could grow multiple times.
No-Knead Bread 2024-12-17T00:00:00+00:00 No-Knead Bread</h1> I grew up eating good bread fresh from an artisan bakery every day. Over the years I've experimented with making and baking my own bread with recipes from the internet but most of it felt flat and it was only this year that I figured out What Worked to make delicious bread that matched that from the bakery. This recipe</a>, itself an adaptation of a NYTimes recipe, is what I've been using as a reference. Refrigerating the dough for a day is really key to develop that great flavour, no need to maintain a sourdough starter. The dough itself comes together without much fuss, and doesn't really require any kneading. I typically replace some of the flour with whole-wheat or spelt flour, for more depth of flavor, nutrition and color. Ingredients</h1> 450g flour use bread flour if you have it. mix with whole grain wheat/spelt flour if you want, for example 300g bread flour + 150g spelt flour</li> </ul> </li> 2tsp instant dry yeast, about 5~6g. a bit less than a 7g packet. or just use the whole packet this is not too fussy</li> 1.5tsp table salt, or between 1.5% - 2% relative to flour in grams. the exact volume measurement depends on the grain size of your salt and how salty you like your bread (personal preference). linked recipe suggests 2tsp for coarser, kosher salt</li> 375ml warm water, around 80% hydration in bakers' percentage. add a little more if using whole grain flour as it absorbs more water, I go by feel. you want a wet and sloppy dough</li> </ul> Recipe</h1> mix flour</code>, yeast</code>, and salt</code> in a large mixing bowl</li> add water</code> and mix until wet dough forms</li> cover and let rise at room temperature for about 2 to 3 hours</code>, it should double in size</li> refrigerate, at least overnight, a whole day is better, possibly longer. optionally, every couple hours take dough out to do a couple folds over itself and put it back. this helps develop gluten</li> take dough out of the fridge, flip it onto parchment paper dusted with flour, let it come to room temperature and proof, about 45min. preheat oven to 200C</code> in the meantime</li> transfer parchment paper with dough onto oven tray, spray with water to create a steamy environment in the oven and bake until golden brown (~45m)</li> remove and let cool</li> </ol> How I make my Oatmeal 2024-09-24T00:00:00+00:00 Over the past few months, I've really come to enjoy oatmeal. I'm from a country where it's not a common food at all and I never knew of it growing up, but now it's become my breakfast of choice most days, and I have experimented with many variations of it which I wanted to share: Sweet Variations</h1> This is how I like to have oatmeal most of the time, with some sweetener and maybe flavorings and topped with fruit, nuts, and often nut butter. My go-to lately is with vanilla-flavored soy protein powder, a sliced banana, peanut butter, nuts and dark chocolate. I usually add raisins and a sprinkle of cinnamon too. I cook my oats on the stove-top at a low simmer for 10 to 15 minutes so they soften and absorb a lot of water. As for measurements, I do ½ cup of rolled oats (though lately I've been doing ¼ cup oats + ~10g oat bran) and ½ tsp chia seeds, cooked in initially ~1 cup of liquid (water, plant milk, or a combination) with a pinch of salt. I add more plant milk or yogurt as it thickens because I like it on the looser end. I mix in the protein powder at the end of cooking if I'm adding it, or I'll add some sweetener to taste (maple syrup/honey/stevia/a combination). I prefer old fashioned rolled oats for texture, as opposed to the quick cooking kind. Savory Variations</h1> Some days I crave something savory in the morning instead, but it's also a quick & comforting option for dinner. Apparently people in the English-speaking internet find savory oats weird, but I didn't grow up eating oatmeal of any sort, so I don't have that specific association with sweet oats that seems common. To me it's just another cereal grain like rice, so it makes sense for savory dishes too. Anyway, for savory variations I like creamy and soft oats, similar to congee/rice porridge. Seasoned with salt and some combination of boullion powder, oyster sauce, soy sauce, miso paste... Simple spices like black pepper, maybe turmeric, cumin, smoked paprika.. I love adding spinach and mushrooms, and I often start by sautéeing onions and/or garlic for an aromatic base before adding the rest of the ingredients. Using unsweetened plant milk in addition to water is nice too. Sesame seeds, runny egg, sriracha, nattō, are some great toppings in my rotation. Other interesting variations I've tried: risotto-style with butter, red wine, mushrooms and parmesan</li> tomatoey oats (cooked with tomato puree or tomato sauce), which pair especially well with egg.</li> </ul> Unlike sweet oatmeal, my preference with savory oats is to use the quick cooking kind for the softer consistency. Starting a food diary/blog 2024-09-24T00:00:00+00:00 I've wanted to make use of some of my spare time to do a bit of writing, and food & cooking is something I find interesting and spend time thinking about, plus I like to experiment with cooking as a creative outlet. So writing about it seems like a natural choice, and I get to give this site some more use that way. C99 doesn't need function bodies, or 'VLAs are Turing complete' 2022-02-19T00:00:00+00:00 Preface</h1> The 1999 revision to the C programming language brought several interesting changes and additions to the standard. Among those are variable length arrays, or VLAs for short, which allow array types to have lengths that are determined at runtime. These can show up in different contexts, but for the purposes of this post we will be looking at VLAs as parameters to functions. For example: void f(int n, float v[n]); </code></pre> Since array parameters decay to their corresponding pointer type, that declaration is functionally equivalent, and compatible (6.7.5.3p7</a>) to the following: void f(int n, float *v); </code></pre> The length of v</code> in the first declaration is given by the value of a previous parameter of the function, which can only be known at runtime. However, in a function prototype (i.e. not a function definition) like the above, the length of a VLA parameter is never computed and essentially ignored (6.7.5.2p5</a>). But in a function definition, the length is evaluated and must be greater than zero. In practice this is rather useless because the sizeof operator doesn't work as one might expect it to with array parameters (6.5.3.4-note88</a>): void f(int n, float param[n]) { float local[n]; int a = sizeof local, b = sizeof param; printf("n = %d\n", n); printf("sizeof local = %d\n", a); // this will be n * sizeof(float) printf("sizeof param = %d\n", b); // but this will be sizeof(float *) } </code></pre> In other words, using sizeof with a VLA will evaluate the runtime-known length and calculate the array size based on that, except when that VLA is a function parameter, then, for whatever reason, it is the size of the corresponding pointer type (in this example, sizeof local === n * sizeof(float)</code> but sizeof param == sizeof(float *)</code>). The length of a VLA parameter may be used when e.g. computing indices when accessing multi-dimensional variable length arrays. Alas, the standard mandates that the variable array length be computed when the function is called. Of course, the expression in between the square brackets is not limited to simple expressions like n</code>, so one can write something like: void f(int a, int b, int m[(a + b) / 2]) {} </code></pre> or void f(int x, int b[abs(x)]) {} </code></pre> or even void f(int v[getchar()]) {} </code></pre> Disembodiment</h1> The following program should give you an idea of the kind of constructs that these rules allow for (try it on compiler explorer</a>): int main(int argc, char *argv[printf("Hello")]) { printf(" world!\n"); } </code></pre> The length expression of the VLA is evaluated before any of the statements in main</code>. I couldn't find anywhere in the standard saying whether this evaluation order is well-defined but it is what clang and gcc do, and luckily, it does not matter for the sake of this article, as we will see shortly. Let us refer to the subset of C99 where function bodies must be empty as disembodied C. You might naturally ask yourself what things can be accomplished in this subset (though you can probably guess the answer from the title of this page). In other words, what can you do in C if you are limited to just evaluating expressions and no statements? Using the comma operator, we can sequence arbitrarily many expressions for their side effects, so void f() { printf("Press enter to confirm: "); getchar(); printf("thanks.\n"); } </code></pre> becomes void f(char _[( printf("Press enter to confirm: "), getchar(), printf("thanks.\n"), 1 )]) {} </code></pre> In a comma expression, the operands are evaluated left-to-right and the value of the last operand is the resulting value of the whole expression. The 1</code> at the end ensures that the evaluated array length is >0 (to avoid UB). </li> Functions in disembodied C are going to need a dummy parameter where the VLA length expression evaluation can take place. For consistency, we will denote it as char _[...]</code> and give it the value ""</code> (the empty string) when calling said functions (note that the value we give it doesn't actually matter, though its size should be at least as big as the computed VLA size to avoid UB). </li> If-else statements can be replaced with ternary conditional expressions, such that void f(int n) { if (n < 0) printf("negative!"); else if (n > 0) printf("positive!"); else printf("zero!"); } </code></pre> becomes void f(int n, char _[( (n < 0) ? printf("negative!") : (n > 0) ? printf("positive!") : printf("zero!") , 1 )]) {} </code></pre> </li> Remember that the VLA length expression can access previous function arguments, so parameter passing is essentially unchanged. </li> We cannot return values, but we can use out parameters by taking advantage of the fact that assignments are expressions in C, so instead of int imax(int a, int b) { return a > b ? a : b; } </code></pre> we can write void imax(int *out, int a, int b, char _[ (*out = a > b ? a : b), 1 ]) {} </code></pre> </li> We cannot define local variables inside of expressions, but we can just add extra function parameters to use as temporaries, rewriting void fswapf(float *a, float *b) { float tmp = *a; *a = *b; *b = tmp; } </code></pre> as static void fswapf_aux(float *a, float *b, float tmp, char _[( tmp = *a, *a = *b, *b = tmp, 1 )]) {} void fswapf(float *a, float *b, char _[( fswapf_aux(a, b, 0, ""), 1 )]) {} </code></pre> Alternatively, if re-entrancy and thread-safety are disregarded, we could just use global (static) variables. </li> What about loops? Clearly we cannot use while</code> or for</code> inside expressions. Thankfully, they are unnecessary thanks to recursion. For example: float sum(float *v, size_t n) { float sum = 0.0f; for (size_t i = 0; i < n; ++i) sum += v[i]; return sum; } </code></pre> can be expressed as /* the forward declaration is necessary */ static void sum_aux(float *out, float *v, size_t n, char *); static void sum_aux(float *out, float *v, size_t n, char _[( (n > 0) ? ( *out += *v, sum_aux(out, v + 1, n - 1, ""), 1 ) : 1 )]) {} void sum(float *out, float *v, size_t n, char _[( *out = 0.0f, sum_aux(out, v, n, ""), 1 )]) {} </code></pre> In fact, any imperative-style loop can be turned into an equivalent recursive loop (as any functional programmer will be happy to demonstrate), though since C lacks closures or any form of anonymous functions, it can get quite unwieldy (I hope you like auxiliary functions). The astute reader might point out that these two versions of sum</code> are not equivalent because the recursive definition may cause a stack overflow for large enough values of n</code>. This is unfortunately true, and the major hurdle for the practicality of disembodied C, but does not preclude Turing completeness (an ideal Turing machine</a> has infinite memory at its disposal). Luckily, modern compilers are smart, and if we write our functions carefully to be tail recursive</a>, they will often be able to perform tail call elimination, removing the risk of a stack overflow. For the above example, both gcc and clang are able to optimize the tail call (see on compiler explorer</a>). </li> Although not relevant to standard C99, in case you had the idea of using gcc statement expressions</a> to bypass these limitations, the compiler will stop you right on your tracks since it doesn't allow those outside of function bodies. </li> </ul> Limitations</h1> After all of that, it seems that basically anything can be done in disembodied C, so, is there something that can't be expressed in this C99 subset? With the rules that we've laid down so far, yes. In particular: It is not possible in the general case to use APIs that require callbacks. For example, look at the standard qsort</code> function: void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *)); </code></pre> The compar</code> parameter is a pointer to a function that should return the result of comparing two values in the given array. Since its parameters are void pointers, we can't have the VLA argument we need to perform computations (arrays of void</code> are not valid C), and we also cannot provide an int</code> return value. Thus there is no way (that I know of) to use this function in standards-compliant disembodied C. This is not a dealbreaker since we could just reimplement qsort</code> ;). </li> We cannot access the program arguments. The entry point of a program in disembodied C looks like this: int main(int argc, char *argv[ /* code here ... */ ]) {} </code></pre> In the VLA length expression for argv</code>, argc</code> is in scope, but argv</code> is not. Fortunately there is a way to work around this: we can use the common extension where main</code> can take a third argument which is a pointer to the environment. According to the standard (J.5.1</a>), this is implemented in hosted environments. In practice, POSIX environments and Microsoft both support it. Then, our entry point looks like this instead: int main(int argc, char **argv, char *envp[/* ... */]) {} </code></pre> Now argv</code> is in scope within the envp</code> array length expression. Side note: even though we can't return</code>, main</code> is the exception to the rule that reaching the closing }</code> of a function returning non-void is verboten, and is equivalent to returning zero (5.1.2.2.3</a>). If we need to terminate with an exit code other than zero, we can use exit()</code>. </li> </ul> Final Words</h1> It seems that with enough effort anything can be done with these peculiar restrictions. As an example, I wrote implementations of the MD5</a> and SHA256</a> hash functions as well as Conway's Game of Life using SDL for graphics</a>. I was also working on a more interesting and "useful" program but I kind of lost motivation halfway through. I'll update this article if I ever come back to finish that. In case it wasn't clear enough, there is zero practical reason to ever do any of this. I hope you'll agree it's a fun party trick though :). test post 2022-02-02T00:00:00+00:00 test</h1> lorem ipsum dolor sit amet u16 rng(u16 s){ s^=s<<8,s=(s<<8 |s>>8)^((s&0xff )<<1),s=0x7e00^ (s>>1)^(0x9e74& -(~s&1));return 46497^s?s:s^s;} </code></pre>

Morcilla de Verano Recipe (Eggplant Dip)

A little XOR trick to micro-optimize some integer data structures

No-Knead Bread

How I make my Oatmeal

Starting a food diary/blog

C99 doesn't need function bodies, or 'VLAs are Turing complete'

test post

test</h1> lorem ipsum dolor sit amet</p> u16 rng(u16 s){ s^=s<<8,s=(s<<8 |s>>8)^((s&0xff )<<1),s=0x7e00^ (s>>1)^(0x9e74& -(~s&1));return 46497^s?s:s^s;} </code></pre>

test</h1>
lorem ipsum dolor sit amet</p>
`u16 rng(u16 s){ s^=s<<8,s=(s<<8 |s>>8)^((s&0xff )<<1),s=0x7e00^ (s>>1)^(0x9e74& -(~s&1));return 46497^s?s:s^s;} </code></pre>`