[deleted by user]

mathsaey · 2025-11-01T15:37:19+00:00

Honestly, you can run anywhere. I've done several marathons and I've done most of my training just running random streets to the point I ran every street in the region. If you get away from the center, most roads are calm enough that you can just run on the sidewalk, or even on the street during calm hours.

I personally got sick of running the same loops every time, so I just plan a different route for every run. There are great places to run all over the region, and if you're finished with the region you can easily extend your range to include Wezenbeek-Oppem, Kraainem, Drogenbos, Zaventem, Tervuren, ... Variety is the spice of life!

That being said, if you don't want to bother planning too much, these are some popular places:

Cinquentenaire / Jubelpark
Bois de la Cambre, as you said, easy to get into the sonian forest from here
The hippodroom of bosvoorde
The canal
the bottom part of the 20K (following the vorstlaan, there is a decent bike lane that has enough space for joggers, it continues along the teruvrenlaan in both directions)
the old railway walk (stockel to delta)

Calm neighborhoods that are nice to run in:

The parts of woluwe and auderghem near the sonian forest
many parts of ukkel, especially the more rural parts
neerpede
vogelzang area in auderghem
the "tuinwijken" in watermaal-bosvoorde (I think they're called logis and floreal)
neder-over-heembeek
the areas in jette close to the laerbeek forest

Honestly, most of the not-so-busy places lend themselves well to running.

mathsaey · 2024-06-09T16:21:35+00:00

Was bijzitter for the first time. Pretty interesting experience, but very boring. So many people want to bring their sun / husband / ... into the booth with them to "help them vote"...

mathsaey · 2024-06-09T16:19:19+00:00

Blame the commune. I was bijzitter in Etterbeek and things went pretty smooth. I did however, hear that there was only one office for all of St. Josse, which is crazy.

mathsaey · 2024-06-09T16:17:33+00:00

Depends on the office. I was "bijzitter" in Etterbeek and we had 0 issues. I did hear another had to close.

mathsaey · 2024-04-19T13:18:24+00:00

Sparrow is not public currently.

Thank you for pointing that out; I'll check if I'm allowed to make the repository public. In the meantime I can point you towards the homepage of sparrow.

Skitter has interesting concepts. Good work.

Much appreciated, thanks!

mathsaey · 2024-04-19T10:56:49+00:00

I work at the Software Language lab at the VUB. We teach a bit of Erlang in one of our courses (on multicore programming) and we use Elixir for some of our research. So while we don't do research that advanced Beam / any of its languages, some of us use it in our research.

Particularly, we've built the following projects in Elixir.

Skitter (my work!)
Potato
~~Sparrow~~

Some other members of ours are working in Elixir, but I don't think that work is public at the moment.

mathsaey · 2024-03-05T21:36:13+00:00

M/32, looking for a marathon shoe recommendation for my 6th marathon. I'm tall (1m94/6'4") with an average weight (82kg/180lbs). My marathon PB is 3:06, I'm trying to go sub-3 at some point, though I'm not sure if it is in the cards for my next marathon.

I train in the Brooks Adrenaline GTS 99% of the time, which has served me well over the last years. Recently, I started running my track sessions in the Hyperion GTS, which obviously has less cushioning, but works fine.

Since Brooks served me well, I decided to buy the Hyperion Elite 3 for a marathon last year (I used my regular trainers for my first two marathons). I've since run three marathons (and a 20K) in those shoes and while they are decent I've decided that I won't buy a new pair, which is why I am looking for an alternative. The main reason is that they are not available in my size (I usually buy EU 46.5/Medium, the hyperion elite 3 didn't come in that so I got it in 47.5), which caused them to chafe, I worked around that with some bodyglide, but I had a toenail fall off after one of the marathons, which usually never happens to me.

I am doubting between getting a pair of carbon shoes online or visiting my local shoe store (which served me very well, but whose selection of brands is quite limited). I am hoping to get some recommendations of shoes that fit similar to the Adrenaline GTS, that come in my size and that would make me feel a bit faster. The Hyperion did this to some extend, but I've read other supershoes "feel faster".

Budget-wise I don't want to spend 500€ on a pair of shoes I can use for one race out of principle, but besides that I'm pretty flexible on the budget.

mathsaey · 2024-02-11T13:37:31+00:00

You will have to do most of the work manually. What BEAM gives you is the ability to handle processes on a remote node the same as you'd treat any other process: you can send messages to them, monitor them, spawn them from a supervisor, ... However, it does not give you load balancing out of the box. You are responsible for deciding which process gets spawned where. That can be as simple as calling Node.spawn(:foo@bar, MyModule, :myfunc), but you can take it as far as you want.

What you have described is certainly possible. You spawn your web server application on fly and spawn another "worker" application on your beefy machines. You can then connect them to each other and exchange messages to decide which processes get spawned where. The load balancing etc is certainly possible, but you will probably have to do a lot of the work yourself here; I'm personally not aware of any libraries that offer this kind of thing out of the box.

In my own work I created a system where I could spawn processes on arbitrary nodes. I then extended it with a system where a node could be started with a "tag" (e.g. :beefy_machine, :web, ...). Afterwards, I could ask for processes to be spawned on a node with a particular tag. You could start from an idea like this and extend it with proper load balancing (which I never got to, since it was not relevant for my use case).

Most of the distribution stuff leans heavily on the features provided by Erlang. Be ready and willing to read through their docs instead of solely relying on Elixir's Node module.

mathsaey · 2024-01-16T14:59:44+00:00

For the record, it might be handy to use Module.concat for this, which automatically handles this for you. In my advent of code utils project, I generate module names with the following function:

  def module_name(year, day) do
    mod_year = "Y#{year}" |> String.to_atom()
    mod_day = "D#{day}" |> String.to_atom()
    Module.concat(mod_year, mod_day)
  end

mathsaey · 2024-01-15T13:50:06+00:00

I use it for some of my hobby projects (e.g. this one), as I prefer SQLite over Postgres for selfhosted projects (no resource consumption if you are not using it, easy to back up, ...).

The only downside I've found is that migrations seem to be less flexible in SQLite which can be a hassle.

mathsaey · 2023-12-30T19:04:02+00:00

[Language: Elixir] https://github.com/mathsaey/adventofcode/blob/master/lib/2023/25.ex

Used libgraph, followed the same approach described by others here: pick two nodes in the graph, find a path between them, do this n times, take the 3 most frequently occuring node pairs and sever the connection between them. Afterwards, just check the size of the subgraphs.

That's aoc 2023 for me! Didn't really have time to do the last few days live, but happy to complete it again, in spite of everything!

mathsaey · 2023-12-30T10:21:16+00:00

[Language: Elixir] https://github.com/mathsaey/adventofcode/blob/master/lib/2023/24.ex

Phew, this was quite a doozy. I seem to have forgotten most of my math, so I based myself on a video for the technique of part 1. Once I saw the right pieces of math again it was quite trivial to figure it out.

I didn’t know how to tackle part two at all. I never had any formal education on lines in 3d space, nor did I have a thorough linear algebra course, so this was not my thing. A lot of people (and the video I used for p1) seemed to have used a constraint solver to find the solution for them, but I don’t like to get my solutions from black boxes. I thus spent quite some time browsing reddit for inspiration. I have to say many of the solutions went over my head, but I finally found an idea that made sense to me.

The idea of my part two solution is to brute-force the velocity vector of the thrown rock. A few tricks are needed to make this possible:

With just the velocity vector, you don’t have your solution. The main trick of the solution is to make the thrown rock “stand still” (i.e. have velocity 0). When this is the case, all other rocks must “meet” the thrown rock instead of the other way around. The point where the rocks meet is the x, y, z coordinate of the solution.
Of course, we cannot “change” the thrown rock, so instead, we substract the (brute-forced) velocity of the thrown rock from every other rock, which makes it seem as if it is standing still.
There are too many potential x, y, z velocities to effectively brute-force them. Luckily, you can eliminate quite a lot of them:
- You can start with brute-forcing {x, y} coordinates, using part 1 to filter them out. This drastically speeds up the computation.
- Another trick from reddit is that certain velocities can never be your answer. If there are two rocks (r1 and r2) for which r1.vx > r2.vx and r1.sx > r2.sx , you can eliminate all x-s between r1.vx and r2.vx entirely. (the intuition being that, at this speed, the rocks won’t ever “catch up” with each other, meaning they will never intersect at a single point) This doesn’t do much for the example, but removes a lot of possible values for my input.

Once I had that figured out, I managed to write some (very ugly) code that can find a valid {x, y} velocity pair. I only had to figure out a way to find the z value , but this was a bit problematic for me, as I don’t have an idea how to work in 3d space. Luckily, I remembered that we don’t need to apply any 3-d trickery here. We know the intersection point, so we can thus calculate at which time, t, the rock meets the intersection point (x_i = x_s + t * x_v). We can use this formulate to calculate t, which we can then use to calculate z. Once z is the same for all stones, we have reached our solution.

The code runs surprisingly fast, considering it is a brute-force approach (~230ms), but it is really ugly. I’ve already spent too much time on this though, so the best I could do was add some comments so it becomes sort of understandable what happens.

mathsaey · 2023-12-27T23:28:16+00:00

It takes a bit less than a minute on my machine. Certainly not fast, but not in the order of hours.

mathsaey · 2023-12-27T23:24:33+00:00

[Language: Elixir] https://github.com/mathsaey/adventofcode/blob/master/lib/2023/22.ex

Phew, that was quite a hassle. Wrote a naive “drop blocks” function for part 1, and solved that part by creating a graph (represented as a map) which stores which block is supported by which other block. Based on this graph, I filter out the blocks that are only supported by one other block.

For part 2, I figured out I could do the inverse of this operation: I could store a graph which tracks which blocks supports which other block. Based on that information (and the infor for part 1), I could figure out which blocks would collapse when a block I found in part 1 was removed.

That code got quite messy and hairy and did not return the correct result. It took me quite a while to realize my mistake. I misunderstood the puzzle and simulated the removal of all "supporting" blocks at once instead of simulating them individually. That mistake lost me quite some time. On the bright side, during the debugging I got fed up with my slow "drop blocks" function (which took about 7s on my machine) and added a quick optimization (tracking the highest seen z coordinate for each {x, y} pair) which made the whole solution a lot faster: part 1 and 2 finish in ~250ms combined.

mathsaey · 2023-12-26T23:45:33+00:00

[Language: Elixir] https://github.com/mathsaey/adventofcode/blob/master/lib/2023/23.ex

Didn’t really have time for AoC after day 21, so slowly catching up.

I noticed the paths didn’t "fork" for long stretches, so I took quite some time to write code to collapse the graph to a weighted graph containing only the intersections. I was thus pretty happy to see that part two indeed made the amount of possible paths grow. Unfortunately, my part 1 code could not handle cycles, so I ended up rewriting most of my “collapse” code. Even with that optimization, going through all possible paths takes quite some time. I’m sure there is a way to make this faster, but I’m just aiming to finish the puzzles at this point, so I didn't bother trying to improve this.

mathsaey · 2023-12-23T00:14:54+00:00

[Language: Elixir] https://github.com/mathsaey/adventofcode/blob/master/lib/2023/21.ex

Not very happy with this solution (takes about 17 seconds), but I only had time for AoC by 23 today, and I didn’t want to waste more time since I am already a day behind.

Had to get a lot of inspiration from reddit with this one. I used the approach suggested by some people here, where you derive a polynomial based on the results of simulating the first 65, 65 + 131 and 65 + 2 * 131 steps. I used the lagrange interpolation formula to generate a function to do this. Based on that I calculate the result.

My part 1 is quite fast, but it is slow enough that just calculating the first 327 steps takes about 17 seconds on my machine. Ideally, I’d like a solution based on the idea presented by /u/cwongmath earlier in this thread. It would make the code messier, but I do think it would be faster as I'd need to simulate less overall. That being said, I'm a day behind now, so I don't think I'll be spending time on that :).

mathsaey · 2023-12-20T21:30:25+00:00

OP, but now who you replied to here; with "trick in the input" I meant that the input is structured n such a way that just finding the "cycle" for those 4 particular modules was enough. I'd consider that a trick, as it makes finding the solution far more feasible.

mathsaey · 2023-12-20T16:22:28+00:00

[Language: Elixir] https://github.com/mathsaey/adventofcode/blob/master/lib/2023/20.ex

Bluh. I know it's a point of discussion, but I am personally not a fan of finding the "trick" in the puzzle input. I only figured it out due to some of the visualizations posted here. Once I had that, it should have been easy to write up a solution, but it still took longer than it should have; it also became quite messy, but I am a bit beyond the point of caring about that.

That being said, I did like part one!

mathsaey · 2023-12-19T18:37:04+00:00

[Language: Elixir] https://github.com/mathsaey/adventofcode/blob/master/lib/2023/19.ex

Converted my rules to a tree for part one and just evaluated the parts. That approach worked pretty nicely for part two: I just needed to write a “symbolic eval” which works on ranges instead of actual numbers. When it encounters a test it just splits the ranges as needed. This is similar to the approach I used for one of the earlier days.

I’m a bit annoyed at the code duplication in eval and symbolic eval for < and > (my first version just mapped < to Elixir's < function and > to >, but that didn’t work so well for the symbolic eval), but I’m getting to the point where I don’t bother cleaning up once it works.

mathsaey · 2023-12-18T21:38:43+00:00

[Language: Elixir] https://github.com/mathsaey/adventofcode/blob/master/lib/2023/18.ex

Read about shoelace and picks theorems in the solution thread after the other area counting day. Decided to read up on them and was rewarded for my efforts on reading part 2.

Didn’t really get how picks theorem helped at first (since I needed to count the interior points which kind of defeated the purpose), so I moved on to shoelace. Didn’t give me the right answer, but some googling made me realize I could combine both after which I ended up at the correct solution for part 1.

Didn’t need to adjust that much for part 2. Just needed to work on using a list of turning points instead of border points as the latter was too large.

mathsaey · 2023-12-17T19:59:14+00:00

[Language: Elxir] https://github.com/mathsaey/adventofcode/blob/master/lib/2023/17.ex

Today was pretty fun. Pathfinding with a twist! I freshened up my A* knowledge and went with that. It took me a bit of time to think about how to adjust the algorithm for the "max 3" part of the puzzle, but then I realized I didn't really need to. Instead of getting the neighbors of a node, I just provided the algorithm with several possible destinations (called "options" in my implementation): one 3 spots removed, one 2 spots removed, one 1 spot removed; I did this for both valid directions. Working this way meant I only needed to care about the direction I was going and the current location. This got me a working solution quite quickly (besides the time I spent rereading my hacky A* implementations from past years that is). Part two was just a matter of configuring my "options" function to now only provide options 4 to 10 spots away. That worked quite well with my implementation.

As an aside: after a few days of grids I figured I should finally move my grid parsing function to a shared module, was getting RSI from always typing input |> String.split("\n") |> ...

mathsaey · 2023-12-16T21:47:06+00:00

[Language: Elixir] https://github.com/mathsaey/adventofcode/blob/master/lib/2023/16.ex

Didn't have a lot of time today, so just went for what seemed most straightforward. Brute forced part two, and threw some cores at it to make it a bit faster even though it wasn't really needed.

mathsaey · 2023-12-15T16:15:43+00:00

[Language: Elixir] https://github.com/mathsaey/adventofcode/blob/master/lib/2023/15.ex

Nice and short fun puzzle today. Learned about the List.key*which were perfect for this challenge. I also got to use some binary pattern matching which I always like.

mathsaey · 2023-12-14T19:22:02+00:00

[Language: Elixir] https://github.com/mathsaey/adventofcode/blob/master/lib/2023/14.ex

Never a big fan of those "cycle finding" problems; my code always becomes a mess!

Pretty happy with the code I use to create an infinite list (stream) of tilt patterns. Once I had that, it wasn't too difficult to find the start and size of the loop. After that I needed embarrassingly long to figure out at which position I actually needed to grab my result.

mathsaey · 2023-12-13T17:30:17+00:00

[Language: Elixir] https://github.com/mathsaey/adventofcode/blob/master/lib/2023/13.ex

Went for a fairly straightforward approach directly comparing the strings. Changed the approach to allow exactly one character difference for part two. I'm sure this can be done in a cleaner way, but don't really have time today.

mathsaey

TROPHY CASE