So it started with my current book shelve, some personal memories, a few online “list of best SF books” (in French) and a series of iterative prompts on LLMs to expend it, refine it, etc.

I have now published a cleaned-up version as a permanent page: Les 330 meilleurs livres de science-fiction et fantasy. Warning: the page is in French, listing the French editions and is meant for French-speaking readers.

Each entry has a theme and a one-line summary, so you can browse it instead of scanning bare titles. And it comes with three guided reading paths: one for an adult who used to read a lot and wants to get back into it (short books first, always a short story collection on the side, big cycles last), one for a strong reader of 12 years oald, which climbs from Stefan Wul’s Niourk all the way to Dune over a year or two, and one for a 13-year-old who prefer the romance but has a taste for fantasy as well.

I will most likely update it along the following weeks, months and years!

Time-lapse of the setup of my old CGEM Celestron mount and the TS APO 65/420 refractor telescope, with an ASI178MM black and white camera (planetary, but cooled by a DIY Peltier module for longer exposure deep-sky imaging).

Taken on 2023-02-20 near Paris.

Part 1 - 25min from 18:42

Initial assembly and positioning of the mount, the scope, the heaters, the cameras, and all their cable.

Short break: I stopped the recording after approximately 25 minutes, while I had to wait for the night to fall, for the Polaris north star to appear in the sky.

Part 2 - 30 min from 19:26

When Polaris (the north star) appears in the sky, it’s time to align the equatorial mount with the Earth’s axis of rotation. After that, I point the mount successively to Venus & Jupiter planets, a star I forgot, then Capella giant & Betelgeuse supergiant stars, to calibrate precisely its orientation.

After that, I am ready to start my imaging sessions (from inside the house): tonight it’s the Monkey Head nebula (NGC 2174) in H-alpha (Hα, with a wavelength of 656, in the red).

Footnotes

I’ll try to retake this in 4K and without the midle break. I should be able to get a better quality overrall.

TODO: I should also post a retrospective on how I built the little DIY Peltier module, and link it here.

edit 2026-05-25: added a few commands around finding which executable is actually being used on Windows, and a couple of related PATH debugging tricks.

Benchmarking .NET 7

I got started by this video

Measure-Command

Default output of Measure-Command, using git.exe as a benchmark for a real-life native application:

PS C:\> Measure-Command { git.exe --version | Out-Default }
git version 2.35.1.windows.2


Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 0
Milliseconds      : 47
Ticks             : 476314
TotalDays         : 5.51289351851852E-07
TotalHours        : 1.32309444444444E-05
TotalMinutes      : 0.000793856666666667
TotalSeconds      : 0.0476314
TotalMilliseconds : 47.6314

we can limit the result to TotalMilliseconds only:

PS C:\> ( Measure-Command { git.exe --version } ).TotalMilliseconds
47.8714

comparing to a full C# command line application using .NET runtime, this time Plastic SCM

PS C:\> ( Measure-Command { cm.exe version } ).TotalMilliseconds
395.9726

with a simple C# console app I get better results (note that in this instance the Release build doesn’t run any faster):

PS C:\Workspace\NETConsoleApp1> (Measure-Command {.\bin\Debug\net7.0\NETConsoleApp1.exe}).TotalMilliseconds
83.2977

Then, publishing as a Native application, Ahead Of Time (AOT) compilation of .NET 7.0:

dotnet publish -r win-x64 -c Release -p:PublishAot=true

gives us a bigger application, but much faster to start:

PS C:\Workspace\NETConsoleApp1> (Measure-Command {.\bin\Release\net7.0-windows7.0\win-x64\publish\NETConsoleApp1.exe}).TotalMilliseconds
24.717

ConvertFrom-Json

An equivalent to unix | jq Json reader/formatter in PowerShell

curl.exe http://localhost:18104/api/xxx -X GET -H "content-type: application/json" --header "Authorization: <token>" | ConvertFrom-Json

Find which executable is actually being used

In PowerShell, list all matches across PATH, in the order they would be resolved:

Get-Command cmake.exe -All | Select-Object Source

Or, the cmd.exe equivalent (also works from PowerShell since it is just an .exe):

where cmake

Resolve the single path that will be executed

If you just want the one binary that would actually run:

(Get-Command cmake.exe).Path

Check the current PATH order

Useful right after the previous command, to understand why the wrong copy wins, listing one entry per line in resolution order:

$env:Path -split ';'

To filter only the likely culprits:

$env:Path -split ';' | Select-String -Pattern 'cmake'

And to do the same for the user-scoped or machine-scoped PATH :

[Environment]::GetEnvironmentVariable('PATH', 'User')    -split ';'
[Environment]::GetEnvironmentVariable('PATH', 'Machine') -split ';'

List environment variables

PowerShell exposes environment variables as a drive:

Get-ChildItem env:
Get-ChildItem env:Path

I have not solved these, but at long last, I have started building my own plane (with the help of my kids :o)!

The Youtube video that got me started (in French, but see similar videos in English that also helped me) is:

Cessna 172 characteristics

Real

• 8.07m lenght from tip of the proppeler to the tail
• 11.02m wingspan
  • 2.54m to the break between wing flaps to ailerons
• 3.45m tail width
• 2.72m height to the tip of the tail
• 2.18m width between the wheels

Model 1/7th

• 101cm 1/8th length
• 159cm 1/7th
  • ?
• 50cm 1/7th
• ?38cm?
• ?

List of hardware

Hardware

Some of this is optionnal, eg to make the plane looks good, some of it is tooling that can be reused for other projects.

• Depron / Extruded Polystyrene Foam Sheets 6mm 80x60cm 8x (24.10€)
• Reinforced adhesive tape 50mm (17.06€)
• Red polypropylene adhesive tape 48mm x 66m (7.95€)
• White polypropylene adhesive tape 48mm x 66m (7.95€)
• Steel cable 1mm x 20m (6.18€)
• Nylon clevis keper clip x20 (15.0€)
• Nylon hinge (6.00€)
• Wheels 64mm 2x (10.47€)
• Carbone fiber plate 3.0mm x 0.5mm x 1m (1.00€)
• Carbone fiber tube 4.0mm x 1m (6.00€)

Electronics

• 1000KV Brushless Motor A2212 13T with 30A Brushless ESC Set 1045 Propeller Accessories Kit Mount (25.49€)
• DTXMX Flysky FS-iA6B 2.4GHz receiver (27.99€)
• Micro Servo 9g x5 (14.99€)
• Y extension cables (10.50€)

• XT30 connectors x2x10 (8.99€)

• Servo tester (5.99€)

Already owned

Hardware I had for a few years, for my tiny drone

• Jumper T12 multi-protocol Tranceiver
• LiPo 3S 300mAh batteries (I will ideally need to switch to +1000mAh for ~100g batteries for longer flights)

Weight issue

Nearly 3 weeks in the slow process, I discoverd that the plane was weighting already close to 800g without the battery, compared to the supposed ready-to-fly 600g.

1. I took a step back and weighted the equivalent of all the hot glue I had used so far; something like 5x20g is added to the plane :o ! That’s bad. So people are using Cyanocrylate (brittle) or dedicated UHU POR like foam glue.
2. Then I weighted the white adhesive tape I had used compared to a new one; some aditional 80g where added to the frame! That’s super bad :(

That’s a hard lesson to learn so far in the project. Going from +600 to +800, ie adding 33% more weight is a big issue especially for a beginer trainer airplane.

Now, this has muliple consequences;

Wheels

Landing wheels where never robust enough, but now with all the extra weight, they are bending way to much, and I had to make them more straight.

Balance issue

Now that’s not all! With all this added weight, the plane is quite tail heavy, and this is also bad. Impossible to fly without adding more weight to the tip; I would need to buy bigger batteries and put them at the very front.

Solutions

So now, I’ll have to make sure to remove as much of the white adhesive tape, starting with the tail. And I’ll make sure to weight all what I remove to take note of what I am saving their. After that, removing further to the fuselage can help even more with the weight, but won’t play too much with the balance of the plane. Finaly, for the wings I think that I prefer to keep them like that for extra durability, but it will depend of my results with the above weight removal.

In order to move more weight to the front, it could be good to cut and reglue the motor support a centimeter toward the tip, which would move something like 80g. A good win! Just quite destructive, especially since I already cut & reglue it once. In fact, there is probably too much glue to it.

Another option to consider would be to dig into the fuselage to cut through some pieces and remove some of them, especially remove some part that are glued in order to remove the glue with it. But I fear that this would be much more invasive, destructive & maje the airplane more fragile.

But at this stage, it might be better to just fly the plane until I crash it to hard, and build another one from scratch with all this experience aquired.

Results

I was able to shave off ~28g from the tail and the rear of the fuselage. From a balance perspective it’s a game changer.

Other similar DIY videos

Footnotes

I’ll make sure to update this post with pictures of the work in progress.

Cheers!

This thanks to Unity Technologies acquiring Codice Software to bring Plastic SCM version control to real-time 3D workflows back in August 17, 2020.

Hey, I have started working at @Unity!
Part of my job will be to improve @PlasticSCM support in @UnrealEngine ;)
Nice, right?

— Sébastien Rombauts (@SRombauts) February 22, 2022

Highlights:

• C++11 is now the minimum, along with CMake 3.1 and Visual Studio 2015.
• Continuous integration moved to GitHub Actions, with Valgrind memcheck added on Travis CI.
• Database::backup() now goes through the Backup class instead of a separate C implementation.
• Removed Statement::isOk(), deprecated back in 2.2.0 in favour of hasRow().

By this point the library had grown well beyond the small wrapper I started in 2012: it is used in a lot of projects, and it is still maintained today (latest release 3.3.3 in May 2025). Code, documentation and examples on GitHub: github.com/SRombauts/SQLiteCpp.

Previous milestone: SQLiteC++ 2.0.0.

edit: ¹

I have finally ordered a Beta75X 3S Tiny Whoop quadcopter drone from BetaFPV. I won’t use if with FPV mask or goggles for now, until I know what I would like to do with it. I feel that’s the perfect format for me to start with; it’s usable by a begginer completely indoor, and then it’s also easy to try it outdoor even in very small areas. And finally, with it beeing so small, it’s also something easy to transport for a weekend or vacations, and enjoy anywhere.

I am posting this to be able to share quickly with friends, and for me to find back all the technical details in no time.

Beta75X 3S Tiny Whoop Quadcopter

• weight 45.3g
• 1103 8000Kv brushless motors
• F4 2-4S AIO 12A Flight Controller (FC)
• Customized EOSV2 Camera, with 25/200mW VTX
• 75mm between motors in diagnoal
• I choose the DSMX micro receiver

Batteries 350mAh 2S

• I am actually starting with their 2S batteries that should be easier to learn how to fly indoor
  • 2S 7.4V 35C (70C peak)
    • the 8000Kv motors can thus reach ~59k RPM
  • 350mAh
  • weight 20g, dimensions 57x16x12mm
  • XT30 connector, 20AWG wire
  • JST-XH balance lead connector
  • Flight time ~4 minutes

Batteries 300mAh 3S

• The plan is to upgrade later to their 3S batteries to offer much increased power
  • 3S 11.1V 45C
    • the 8000Kv motors can thus reach ~59k RPM
  • 300mAh
  • weight 26g

Jumper T12 Plus Radio Controller and Transmitter

• Jumper T12 Plus (hall) black
• 2.4ghz Multi-Protocol Module, on the JR/FrSKY compatible module bay
• 16 channels, 12 actuators:
  • 4x Hall Effect Gimbals (ch1,2,3,4)
  • 2x 2-state switches
  • 4x 3-state switches
  • 2x aux wheels
• Open TX Software
• 1.7” LCD screen (tiny)
• Weight: 342g (without battery)
• 2S lipo battery, through the JST-XH balance lead connector
  • I ordered an Azpro 2s 1000mAh 45C (5C charge)
• Simulator mode: 3.5mm standard ppm output or USB HID

HTRC T240 Duo Lipo Charger

• Dual charger, 1S-6S LiPo batteries (but also LiFe, NiCd, NiMh etc)
• LCD screen, programmable charge rates with memory, battery diagnostics
• 240V AC or 12V DC input

Future

The firmware are open-source, and also configurable and programmable, which is especially important on the flight controller, so I might dig deeper into these.

As for the hardware, I might consider buying a FPV screen/mask to fly arround. It is possible that I will wait instead for HD digital solution to take over, as the analog old school TV look of it is not my favorite…

I might one day opt for a bigger drone, into the cinewhoop category for example.

RC Planes

Edit December 2022: the future is there, and I have now built not one, but two RC planes! See DIY Depron RC Plane.

Today was my last day at my company, after many (many) years of good and loyal services... Next week I start at @WeDareWise as a senior programmer to work on @UnrealEngine and @Improbableio's #SpatiaOS! #ue4 #dreamjob

— Sébastien Rombauts (@SRombauts) March 30, 2018

I had met recently their Technical Director while he was evaluating my Plastic SCM plugin for Unreal Engine 4 for use by the studio!

edit: Project C was first revealed in March 2018 and renamed Life Beyond in 2019. Here is Darewise’s reveal trailer:

Existing online documentation

1. Edit: There is now a brand new official documentation of Unreal Swarm!
2. UDK’s documentation Unreal Swarm – Massive Application Distribution for Unreal Engine 3 is actually quite good, though not entirely up-to-date
3. UE4’s documentation Lightmass Global Illumination is more high level, and lacking a section on Swarm Settings
4. Brian Goodsell’s Tutorial: Setting Up Swarm for Multiple Machines is very good but slightly out-dated, not saying how to install the Swarm tools
5. Niberspace’s Is UE4 Distributed Rendering Worth It? gives information on the performances you can expect of it
6. Baking with Swarm gives a lot of in-details technical information (but far too much)
7. Edit: Swarm Agent Troubleshooting (wiki) seems to be the source of some of the official documention :)
8. Edit: And now, a great Youtube tutorial:

What is Swarm

The Swarm Agent is the process launched in the background (daemon) when you hit “Build Lighting” on your Unreal Engine Editor. That is, it is the application that bake your lighting in the UE Lightmass. By default it uses your computer’s CPU cores to do so.

The Swarm Coordinator is a sibling process that you can launch manually to distribute your Lighting build on multiple Agents across the network.

Installation of Agent/Coordinator

Installation on a Windows 7/8/10 64 bits up-to-date is straightforward:

1. You need the .NET 4.0 framework, which comes by default with any recent version of Windows.
2. You should also deactivate the power saving/standby mode on every PC, else it will disable the Swarm Agent on the sleeping machines.

Note that this should also work on Linux & macOS with wine.

To install, you can either:

1. Use existing installation of Unreal Engine on each computers of the network. All versions are cross-compatible so you can distribute your Lightmass work to Swarm Agents of outdated UE4 installation without any problem.
2. Or, on computers without UE4, just copy the content of the Engine/Binaries/DotNET folder. You don’t need all this files, and no subfolders, but the whole is only a few MB in size. Put this on a fast disk with more than 10 GB free space for Agent cache.

You need to choose an always-on machine, like a small/old server to act as the Swarm Coordinator. If you don’t have one, you can select any other Agent machine to host the Coordinator, but you should ensure that it stays online all the time you need it! On my use-case, I’ve selected my laptop (named “ASUS-I7”) to be the Coordinator, so that I can use it when away.

Lastly, you should ask the system to auto-start the Swarm Agent (and/or Coordinator on the selected machine) when the user log-in. To do so, put a shortcut to the executable on the Windows Startup folder, which is located here:

C:\Users\x\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\

Swarm Agent Settings

The Coordinator does not really need any settings. You need to accept the Windows Firewall request to let it communicate freely, though!

The Swarm Agent needs to be told how to distribute it’s work. To do that, launch the Swarm Agent if it is not already running, and double-click on it’s small icon hidden on the tray bar:

Go to the “Settings” tab of its UI:

Here, the only important Settings are (in bold those you need to change):

• AgentGroupName: Default (is fine)
• AllowedRemoteAgentGroup: Default (to match, instead of DefaultDeployed)
• AllowedRemoteAgentNames: * (to match everything, instead of RENDER*)
• CoordinatorRemotingHost: ASUS-I7 (name or IP of the Coordinator computer)

Whenever you set the last one, the Coordinator should start to show the new Agent as soon as it connects across the network:

Usage

Next time you build your lighting on any computer correctly configured, you should get your work distributed across multiple Agents, assuming that:

1. the Coordinator is up,
2. other Agents are running, connected and Available (not Busy, Working, nor Dead),
3. and your workload is big enough to distribute (enough mesh to bake lighting onto)

At this stage, a look at the local Agent will tell show you the following Status:

A look at the Coordinator will tell you the Agent(s) involved in the work:

I hope this can help, and show how all this is incredibly easy and worthy to setup!

Highlights:

• sqlite3.h is no longer included from the public headers. The wrapper forward-declares what it needs, so your code can use SQLiteC++ without pulling the SQLite C header into your own include path.
• New Statement::bindNoCopy() methods that pass SQLITE_STATIC to SQLite, avoiding an internal copy of the bound string or blob when you can guarantee the buffer outlives the statement.
• Variadic-template bind() to bind several parameters in a single call.
• Database::VERSION for the SQLiteC++ version known at compile time, plus getLibVersion() and getLibVersionNumber() for the SQLite version at runtime.
• Clearer exception messages, a uint32_t bind with Column::getUint(), and the bundled SQLite updated to 3.13.

Code, documentation and examples on GitHub: github.com/SRombauts/SQLiteCpp.

edit: the next milestone is SQLiteC++ 3.0.0.

note: ¹