Tristan Brindle
@tristanbrindle.com
Very fortunate to have the one and only Herb Sutter as a guest speaker at C++ London this evening
June 13, 2025 at 7:12 PM
Very fortunate to have the one and only Herb Sutter as a guest speaker at C++ London this evening
I've just posted a long old update about my plans for the Flux library, focusing on ease of use, performance and a potential future standardisation effort.
I'm keen to get feedback at this stage so please head on over to Github and leave a comment if you so choose...
github.com/tcbrindle/fl...
I'm keen to get feedback at this stage so please head on over to Github and leave a comment if you so choose...
github.com/tcbrindle/fl...
The Road to Flux 1.0 · tcbrindle flux · Discussion #242
Flux has been around for a couple of years now, and the feedback I get is mostly that people seem to think it's pretty good. I think it's pretty good too! But I'm also aware that the current design...
github.com
May 29, 2025 at 10:13 PM
I've just posted a long old update about my plans for the Flux library, focusing on ease of use, performance and a potential future standardisation effort.
I'm keen to get feedback at this stage so please head on over to Github and leave a comment if you so choose...
github.com/tcbrindle/fl...
I'm keen to get feedback at this stage so please head on over to Github and leave a comment if you so choose...
github.com/tcbrindle/fl...
I'm a bit of an AI skeptic, but I thought I'd give Copilot a go in VSCode since it's now free. After writing some documentation in Markdown format, I asked it to check for any spelling or grammar mistakes. It insisted, repeatedly, that I had misspelled words *that didn't even appear in the document*
May 29, 2025 at 3:52 PM
I'm a bit of an AI skeptic, but I thought I'd give Copilot a go in VSCode since it's now free. After writing some documentation in Markdown format, I asked it to check for any spelling or grammar mistakes. It insisted, repeatedly, that I had misspelled words *that didn't even appear in the document*
Reposted by Tristan Brindle
📢 Episode 225 is out! 📢 In this episode, @elbeno.com and I chat with @tristanbrindle.com about plans for @cppnorth.bsky.social, future Flux plans, the slow death of Twitter and more! adspthepodcast.com/2025/03/14/E...
March 14, 2025 at 7:05 AM
📢 Episode 225 is out! 📢 In this episode, @elbeno.com and I chat with @tristanbrindle.com about plans for @cppnorth.bsky.social, future Flux plans, the slow death of Twitter and more! adspthepodcast.com/2025/03/14/E...
Reposted by Tristan Brindle
📢 Episode 224 is out! 📢 In this episode, @elbeno.com and I chat with @tristanbrindle.com about updates in Flux, internal iteration vs external iteration and more! adspthepodcast.com/2025/03/07/E...
March 7, 2025 at 4:13 PM
📢 Episode 224 is out! 📢 In this episode, @elbeno.com and I chat with @tristanbrindle.com about updates in Flux, internal iteration vs external iteration and more! adspthepodcast.com/2025/03/07/E...
Reposted by Tristan Brindle
📢 Episode 223 is out! 📢 In this episode, @elbeno.com and I chat with @tristanbrindle.com about the recent C++ London meetup, the status of safety in C++ and the future of C++ and whether it is dying ☠️ adspthepodcast.com/2025/02/28/E...
February 28, 2025 at 1:13 PM
📢 Episode 223 is out! 📢 In this episode, @elbeno.com and I chat with @tristanbrindle.com about the recent C++ London meetup, the status of safety in C++ and the future of C++ and whether it is dying ☠️ adspthepodcast.com/2025/02/28/E...
Reposted by Tristan Brindle
📢 Episode 222 is out! 📢 In this episode, @elbeno.com and I chat with @tristanbrindle.com about graph algorithms resources 📊, tropical semirings 🌴, Stepanov stories 📖, FM2GP 📓, EOP 📙, TV shows & movies 📺 and more! adspthepodcast.com/2025/02/21/E...
February 21, 2025 at 1:23 PM
📢 Episode 222 is out! 📢 In this episode, @elbeno.com and I chat with @tristanbrindle.com about graph algorithms resources 📊, tropical semirings 🌴, Stepanov stories 📖, FM2GP 📓, EOP 📙, TV shows & movies 📺 and more! adspthepodcast.com/2025/02/21/E...
An all-star lineup discussing contracts for #cplusplus at C++ London
January 20, 2025 at 7:05 PM
An all-star lineup discussing contracts for #cplusplus at C++ London
I've found the last few days pretty tricky, so #AdventOfCode day 18 was a nice change of pace. Dijkstra's algorithm came up a couple of days ago so I had an implementation ready to go, and then std::partition_point() does all the hard work for part 2. I like this one!
{
return self.data[pos.y * Size + pos.x];
}
};
template <int Size, std::size_t N>
auto part1(std::span<position const> bytes) -> int {
grid_t<Size> grid{};
flux::for_each(bytes.first<N>(),
[&](position const& pos) { grid[pos] = true; });
return dijkstra(graph_t{grid}, {0, 0}).at(grid.target);
}
template <int Size, std::size_t Skip>
auto part2(std::span<position const> bytes) -> position {
auto idx = *std::ranges::partition_point(
std::views::iota(Skip, bytes.size()), [&](std::size_t n) {
grid_t<Size> grid{};
flux::for_each(bytes.first(n + 1),
[&](position const& pos) { grid[pos] = true; });
return dijkstra(graph_t{grid}, {0, 0}).contains(grid.target);
});
return bytes[idx];
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreicdo2lfhhgl54mxbnzgcq4jwwrfvfry47zlxxd35cqe7radrb2bzu@jpeg)
December 18, 2024 at 1:00 PM
I've found the last few days pretty tricky, so #AdventOfCode day 18 was a nice change of pace. Dijkstra's algorithm came up a couple of days ago so I had an implementation ready to go, and then std::partition_point() does all the hard work for part 2. I like this one!
A frustratingly vague #AdventOfCode day 14, where we're asked to "find a picture of a Christmas tree" with no absolutely no further details. I solved it by the ingenious method of dumping 10,000 ASCII "pictures" to a text file and searching for "*********". I'm not proud!
At least part 1 was easy.
At least part 1 was easy.
 -> std::vector<robot> {
constexpr auto& regex = R"(p=(-?\d+),(-?\d+) v=(-?\d+),(-?\d+)\n?)";
return flux::map(ctre::tokenize<regex>(input),
[](auto result) {
auto [_, px, py, vx, vy] = result;
return robot{.pos = {px.to_number(), py.to_number()},
.vel = {vx.to_number(), vy.to_number()}};
})
.to<std::vector>();
};
template <vec2 Bounds>
auto const part1 = [](std::vector<robot> robots) -> int64_t {
// Move robots
for (auto& [pos, vel] : robots) {
pos += 100 * (vel + Bounds);
pos.x %= Bounds.x;
pos.y %= Bounds.y;
}
// Calculate safety factor
std::array<int64_t, 4> quadrants{};
for (auto const& [pos, _] : robots) {
if (pos.x < Bounds.x / 2) {
if (pos.y < Bounds.y / 2) {
++quadrants[0];
} else if (pos.y > Bounds.y / 2) {
++quadrants[1];
}
} else if (pos.x > Bounds.x / 2) {
if (pos.y < Bounds.y / 2) {
++quadrants[2];
} else if (pos.y > Bounds.y / 2) {
++quadrants[3];
}
}
}
return flux::product(quadrants);
};](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreie7ugjyzxyessiw2s4fjtmkbc7tkegm3fmooqtjkkffg5gzohca6a@jpeg)
December 14, 2024 at 4:55 PM
A frustratingly vague #AdventOfCode day 14, where we're asked to "find a picture of a Christmas tree" with no absolutely no further details. I solved it by the ingenious method of dumping 10,000 ASCII "pictures" to a text file and searching for "*********". I'm not proud!
At least part 1 was easy.
At least part 1 was easy.
Ah, #AdventOfCode day 13, in which I fail to spot that we're solving a system of two simultaneous equations despite allegedly holding multiple degrees in mathematics AND WRITING THE EQUATIONS DOWN IN FRONT OF ME 🤦♂️. I got there in the end though.
github.com/tcbrindle/ad...
github.com/tcbrindle/ad...
![struct game_info {
vec2 a;
vec2 b;
vec2 prize;
};
auto solve(game_info const& game) -> std::optional<i64>
{
auto [a, b, prize] = game;
i64 i = b.y * prize.x - b.x * prize.y;
i64 j = -a.y * prize.x + a.x * prize.y;
i64 det = (a.x * b.y) - (a.y * b.x);
if (det == 0 || i % det != 0 || j % det != 0) {
return std::nullopt;
} else {
return 3 * i / det + j / det;
}
}
auto part1(std::vector<game_info> const& games) -> i64
{
return flux::ref(games).map(solve).filter_deref().sum();
}
auto part2(std::vector<game_info> const& games) -> i64
{
return flux::ref(games)
.map([](game_info g) {
g.prize += vec2{10000000000000, 10000000000000};
return solve(g);
})
.filter_deref()
.sum();
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreifadiebu5ffdkqnt4y6uo6nrdq5cs7m5x2ilrru35q5v6tn7mbf2e@jpeg)
December 13, 2024 at 1:06 PM
Ah, #AdventOfCode day 13, in which I fail to spot that we're solving a system of two simultaneous equations despite allegedly holding multiple degrees in mathematics AND WRITING THE EQUATIONS DOWN IN FRONT OF ME 🤦♂️. I got there in the end though.
github.com/tcbrindle/ad...
github.com/tcbrindle/ad...
Exponential growth was the enemy in #AdventOfCode today!
A simple vector was good enough for part 1, but more iterations in part 2 required a different approach. I went for storing the data in a (value, count) hash map, which worked very well. A nice puzzle!
github.com/tcbrindle/ad...
A simple vector was good enough for part 1, but more iterations in part 2 required a different approach. I went for storing the data in a (value, count) hash map, which worked very well. A nice puzzle!
github.com/tcbrindle/ad...
 -> u64 {
stones_map next;
for (auto _ : flux::ints(0, N)) {
for (auto [val, count] : stones) {
if (val == 0) {
next[1] += count;
} else if (auto opt = split_digits(val)) {
next[opt->first] += count;
next[opt->second] += count;
} else {
next[val * 2024] += count;
}
}
std::swap(stones, next);
next.clear();
}
return flux::sum(stones | std::views::values);
};
auto const part1 = blink<25>;
auto const part2 = blink<75>;](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreifyndus3hqvwv626g34qnfiuefrid7sindmhkvlzcpv4jareyfsnm@jpeg)
December 11, 2024 at 3:11 PM
Exponential growth was the enemy in #AdventOfCode today!
A simple vector was good enough for part 1, but more iterations in part 2 required a different approach. I went for storing the data in a (value, count) hash map, which worked very well. A nice puzzle!
github.com/tcbrindle/ad...
A simple vector was good enough for part 1, but more iterations in part 2 required a different approach. I went for storing the data in a (value, count) hash map, which worked very well. A nice puzzle!
github.com/tcbrindle/ad...
A strange #AdventOfCode problem today where you had to solve part 2 in order to get part 1! I'm pretty happy with my solution to this one, runs in ~100µs on my laptop and has my first use of a C++23 recursive lambda.
Github: github.com/tcbrindle/ad...
Github: github.com/tcbrindle/ad...
 -> void {
char value = grid[here];
if (value == '9') {
goals.push_back(here);
} else {
get_neighbours(here)
.filter([&](position p) {
return grid.is_in_bounds(p) &&
(grid[p] == value + 1);
})
.for_each(self);
}
}(start);
flux::sort(goals);
int score = flux::ref(goals).dedup().count();
return {.score = score, .rating = int(goals.size())};
};
auto walk_all(std::string_view input) -> trail_info
{
auto grid = parse_input(input);
return grid.positions()
.filter([&](auto pos) { return grid[pos] == '0'; })
.map(std::bind_front(walk_trail, grid))
.fold([](auto sum, auto info) {
sum.score += info.score;
sum.rating += info.rating;
return sum;
},
trail_info{});
};](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreih4vdzoeeq7vkvn2a3qh4oe4khhgsiogt57thrffttg7bjdhzddli@jpeg)
December 10, 2024 at 4:29 PM
A strange #AdventOfCode problem today where you had to solve part 2 in order to get part 1! I'm pretty happy with my solution to this one, runs in ~100µs on my laptop and has my first use of a C++23 recursive lambda.
Github: github.com/tcbrindle/ad...
Github: github.com/tcbrindle/ad...
No #AdventOfCode screenshots today as my code is super messy and not worth showing off. But it was very satisfying taking the initial 5 minute(!) runtime for part 2 down to ~70ms on my laptop.
github.com/tcbrindle/ad...
github.com/tcbrindle/ad...
github.com
December 6, 2024 at 5:29 PM
No #AdventOfCode screenshots today as my code is super messy and not worth showing off. But it was very satisfying taking the initial 5 minute(!) runtime for part 2 down to ~70ms on my laptop.
github.com/tcbrindle/ad...
github.com/tcbrindle/ad...
Day 5 of #AdventOfCode felt kinda like cheating once I realised that the rules give us an ordering that we can use as a comparator with sort()/is_sorted().
Using a hash set gives about a 10x speedup versus a sorted vector + binary search, but the latter is plenty fast enough for the problem size
Using a hash set gives about a 10x speedup versus a sorted vector + binary search, but the latter is plenty fast enough for the problem size
 { return rules.contains(l, r); };
return flux::ref(updates)
.filter([&](update_t const& u) { return std::ranges::is_sorted(u, cmp); })
.map([](update_t const& u) { return u.at(u.size() / 2); })
.sum();
};
auto part2(rules_t const& rules, std::vector<update_t> const& updates) -> int
{
auto cmp = [&](int l, int r) { return rules.contains({l, r}); };
return flux::ref(updates)
.filter([&](update_t const& u) { return !std::ranges::is_sorted(u, cmp); })
.map([&](update_t u) {
std::ranges::sort(u, cmp);
return u.at(u.size() / 2);
})
.sum();
};](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreif3qzno46poq63dwgvwpntdp5zfrg4w5a3ab3yzspkz4ixfzoqon4@jpeg)
December 5, 2024 at 1:49 PM
Day 5 of #AdventOfCode felt kinda like cheating once I realised that the rules give us an ordering that we can use as a comparator with sort()/is_sorted().
Using a hash set gives about a 10x speedup versus a sorted vector + binary search, but the latter is plenty fast enough for the problem size
Using a hash set gives about a 10x speedup versus a sorted vector + binary search, but the latter is plenty fast enough for the problem size
Day 4 of #AdventOfCode and we're solving word searches!
Part 1 had me scratching my head for a little while, because I didn't account for the fact that an 'X' can be the root of more than one 'XMAS'. Fortunately part 2 was less tricky.
Code: github.com/tcbrindle/ad...
Part 1 had me scratching my head for a little while, because I didn't account for the fact that an 'X' can be the root of more than one 'XMAS'. Fortunately part 2 was less tricky.
Code: github.com/tcbrindle/ad...
![// helper function which returns a sequence that lazily generates
// the 8 length-3 strings originating at [x, y]
auto neighbours = [](grid2d const& grid, i64 x, i64 y) {
return flux::cartesian_power<2>(flux::ints(-1, 2))
.filter(flux::unpack([](i64 i, i64 j) { return !(i == 0 && j == 0); }))
.map(flux::unpack([&grid, x, y](i64 i, i64 j) {
return std::string{grid[x + i, y + j],
grid[x + 2 * i, y + 2 * j],
grid[x + 3 * i, y + 3 * j]};
}));
};
// for each grid position, if it contains an 'X' then find the 8 strings
// surrounding it and count how many of those match 'MAS'
auto part1 = [](grid2d const& grid) -> i64 {
return flux::cartesian_product(flux::ints(0, grid.height),
flux::ints(0, grid.width))
.filter(flux::unpack([&](i64 x, i64 y) { return grid[x, y] == 'X'; }))
.map(flux::unpack([&](i64 x, i64 y) { return neighbours(grid, x, y); }))
.flatten()
.count_if(flux::pred::eq("MAS"sv));
};
// for each grid position, look at a 3x3 window and check whether
// the leading and back diagonals both match either 'MAS' or 'SAM'
auto part2 = [](grid2d const& grid) -> i64 {
return flux::cartesian_product(flux::ints(0, grid.height - 2),
flux::ints(0, grid.width - 2))
.count_if(flux::unpack([&grid](i64 x, i64 y) {
std::string lead{grid[x, y], grid[x+1, y+1], grid[x+2, y+2]};
std::string back{grid[x+2, y], grid[x+1, y+1], grid[x, y+2]};
return (lead == "MAS" || lead == "SAM")
&& (back == "MAS" || back == "SAM");
}));
};](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreihjs5bztylrmdfanhvlyeoot7l5efy3wkfvk4qfp2us776b2bexgu@jpeg)
December 4, 2024 at 3:43 PM
Day 4 of #AdventOfCode and we're solving word searches!
Part 1 had me scratching my head for a little while, because I didn't account for the fact that an 'X' can be the root of more than one 'XMAS'. Fortunately part 2 was less tricky.
Code: github.com/tcbrindle/ad...
Part 1 had me scratching my head for a little while, because I didn't account for the fact that an 'X' can be the root of more than one 'XMAS'. Fortunately part 2 was less tricky.
Code: github.com/tcbrindle/ad...
I forgot to mention, the full code is on Github if you want to take a look: github.com/tcbrindle/ad...
December 3, 2024 at 7:41 PM
I forgot to mention, the full code is on Github if you want to take a look: github.com/tcbrindle/ad...
#AdventOfCode day 3 part 1 was super easy thanks to @hanicka.net's amazing CTRE library. And part 2 is pretty lovely using Flux, if I do say so myself...
 -> int {
constexpr auto& regex = R"(mul\((\d{1,3}),(\d{1,3})\))";
return flux::from_range(ctre::search_all<regex>(input))
.map([](auto result) {
auto [_, a, b] = result;
return a.to_number() * b.to_number();
})
.sum();
};
auto part2 = [](std::string_view input) -> int {
return flux::split_string(input, "do()")
.map([](std::string_view chunk) {
return flux::split_string(chunk, "don't()")
.front()
.map(part1)
.value();
})
.sum();
};](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreibyiq6rpmlx3kgnd6j22j5rdihy4bj7tts7intbn6ffxw5prijg3m@jpeg)
December 3, 2024 at 3:27 PM
#AdventOfCode day 3 part 1 was super easy thanks to @hanicka.net's amazing CTRE library. And part 2 is pretty lovely using Flux, if I do say so myself...
Day 2 of #adventofcode was a little trickier than day 1. There might be more efficient ways but this gets the job done...
 -> bool {
return (is_sorted(seq, std::less{}) || is_sorted(seq, std::greater{}))
&& flux::ref(seq).pairwise_map(abs_diff).all(flux::pred::geq(1)
&& flux::pred::leq(3));
};
// Returns an adapted sequence which skips the element at index n
auto skip_n = [](std::vector<int> const& vec, flux::index_t n) {
return flux::ints(0, vec.size())
.filter(flux::pred::neq(n))
.map([&vec](auto idx) -> decltype(auto) { return vec.at(idx); });
};
auto part1 = [](std::vector<std::vector<int>> const& vec) -> int {
return flux::count_if(vec, is_safe);
};
auto part2 = [](std::vector<std::vector<int>> const& vec) -> int {
return flux::count_if(vec, [](auto const& report) -> bool {
return is_safe(report)
|| flux::ints(0, report.size())
.map([&report](int i) { return skip_n(report, i); })
.any(is_safe);
});
};](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreih23tvasbapay35vuwz6ursgdrylyxqpapqtwjhjqpxhnhpkhxqhq@jpeg)
December 3, 2024 at 11:22 AM
Day 2 of #adventofcode was a little trickier than day 1. There might be more efficient ways but this gets the job done...
I'm a bit late to the #adventofcode party this year, but Day 1 was a nice gentle start
 { return sum + abs(a - b); }, 0, vec1, vec2);
};
auto part2(std::vector<i64> const& vec1, std::vector<i64> const& vec2) -> i64
{
return flux::ref(vec1)
.map([&vec2](i64 elem) { return elem * flux::count_eq(vec2, elem); })
.sum();
};](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreiefksk6wmz4e6fpuiw2hjoq5vmg7swh2dunpjfoktzzxa35ttnd5y@jpeg)
December 3, 2024 at 10:09 AM
I'm a bit late to the #adventofcode party this year, but Day 1 was a nice gentle start
Reposted by Tristan Brindle
We have published a new C++ on Sea 2024 video!
Practical Tips for Safer C++ - Tristan Brindle - C++ on Sea 2024
#coding #cplusplus #cpp #programming #safety
Practical Tips for Safer C++ - Tristan Brindle - C++ on Sea 2024
#coding #cplusplus #cpp #programming #safety
Practical Tips for Safer C++ - Tristan Brindle - C++ on Sea 2024
Watch our latest video on YouTube
www.youtube.com
November 25, 2024 at 4:01 PM
We have published a new C++ on Sea 2024 video!
Practical Tips for Safer C++ - Tristan Brindle - C++ on Sea 2024
#coding #cplusplus #cpp #programming #safety
Practical Tips for Safer C++ - Tristan Brindle - C++ on Sea 2024
#coding #cplusplus #cpp #programming #safety
My @cppnorth.bsky.social 2024 talk "Practical Tips for Safer C++" is now on YouTube. Enjoy! youtu.be/lW_y0N9dZZA
Practical Tips for Safer C++ - Tristan Brindle
YouTube video by CppNorth
youtu.be
November 15, 2024 at 5:26 PM
My @cppnorth.bsky.social 2024 talk "Practical Tips for Safer C++" is now on YouTube. Enjoy! youtu.be/lW_y0N9dZZA
I don't think Sean Baxter is on bsky yet, but if you're interested in seeing how #cplusplus can be as safe as #rust then check out this presentation about his work on memory safety in the Circle compiler: youtu.be/5Q1awoAwBgQ
Sean Baxter: Safe C++
Online presentation by Sean Baxter demonstrating memory safe C++ using his Circle compiler
youtu.be
May 9, 2024 at 5:16 PM
I don't think Sean Baxter is on bsky yet, but if you're interested in seeing how #cplusplus can be as safe as #rust then check out this presentation about his work on memory safety in the Circle compiler: youtu.be/5Q1awoAwBgQ
Finally joined Bluesky. All aboard, there's a bandwagon leaving town...
February 6, 2024 at 6:06 PM
Finally joined Bluesky. All aboard, there's a bandwagon leaving town...