*(int*)0=0;

So i tried to add joints.

These are connections between entities that limit their movement in a specific way. Like rotating around a point or moving along an axis.

Parametrising them is the hard part, what movement should be allowed at what extent? Probably rotation should be the correct thing to do here, but the angles are tricky. How much should be enabled. What should be the target? The damping?

What should happen if too much force is generated at the contact? Should the joint just break? So many questions...

Something you'd like to get involved in if you have time?

Robotics?

I'm interested in the physical world application of programming and I really want to try my hand at hardware stuff. Soldering and mechanical engineering kinda things.

Just reinstalled windows, now nothing works.

A programming/tech thing you feel very strongly about?

Mental health was worse than usual today, couldn't be focusing on anything serious so no progress. Cleaned up the whiteboard to free some space, wiped down where the already implemented ideas were drafted.

What do you most need to work on?

Perfectionism. I need to focus more on finishing things rather than making them perfect (maybe from scratch).

Replaced a heuristics with another one. The results were too funny not to monkey around for a while tweaking it and laughing at the outcome.

The little white dot on the screen represents a light source, namely the sun. It is only for getting visual feedback on the angle (not the position) of the incoming rays. I replaced the dumb (and now literally incorrect) computation that resulted how much energy the plant (or cell? not really sure at this stage) is absorbed.

Now the rays are cast into the world from that dot and actual energy density based on r^-2 method is used. Which is becoming infinite if the light source goes inside the plant. Which happened. That resulted in infinite energy which resulted in exponential growth.

The quick and dirty fix was making too much incoming energy insta kill the plant. This did not solve anything but was a fun experiment.

How's the challenge going so far?

Not bad, had it worse. To be honest I didn't think I would be this consistent but here I am.

The dilemma was: should I take the hard route and reimplement something for learning purposes or bite the bullet rapier and use a library that implements it way better than I ever could.

So i bit the bullet rapier and instead of trying to code it myself I added another library to the project. Which is rapier physics engine written in rust. The bevy plugin was already provided by the crate so the only thing left was adding the systems and the necessary components to the code.

I'm pretty excited because it's the first time i've used a physics engine not written by me (thus having more features and a better performance). Little sad though, but making the project's end goal a priority instead of the potential learning was the right decision here.

What do you think is your strongest skill in terms of programming?

Finding and fixing bugs is what I'm very good at. Especially crash bugs, where you can inspect the core dump like a crime scene. Tracking backwards what could've possibly happened that led to this exact point. At one point in my career when the new trend was adding some buzzword title like 'ninja' or 'guru' to your profile I considered writing coredump necromancer in my bio for doing post mortem debugging so often and especially well.

Optimization, most commonly runtime performance tuning. Not my strongest but pretty much up there. The lower level it gets the more exciting the challenge becomes. Fiddling with register utilisation and vectorisation is really hard, add the memory access patterns and cache collisions to it and I'm ready for the challenge!

I was disheartened and annoyed about yesterday's progress so I went and dove headfirst into it.

Few points I could clear up. Performance wise it was a disaster. It was slowing down with a couple thousands (~30k) of entities and it did not look good for the future. I enabled tracy tracing, and saw that my logic only took microseconds of the frame and the blame was on the rendering. I removed the parts that added anything to render and the slowdown shifted to a couple of millions (~20M) of entities. I feel validated that the original idea of decoupling the rendering was the good solution here. Have to do it correctly when I get there.

The parent-child relationship was removed temporarily, the redesign for that needs other factors to be clarified first. Gonna do some prototyping and see what is the best course of action.

Give us your most nerdy computer fact

I can't rank them on nerdiness so here are a bunch:

Chip design came to a halt/slowdown because we reached the limitations of physics. Most notably the speed of light. Imagine a CPU that is not just some measly 5GHz clocked antiquity but let's say it has 10GHz clock, that means twice as much raw power. 1 cycle takes 1e-10 seconds (0.1 nanoseconds). The light (and any information) travels around 3 cm in that time. That is the hard upper bound of the size of the chip. No problem, let's make smaller transistors then! Turns out the transistor sizes today are pretty close to another limit. The small scales enable some really weird and wacky things to happen. Quantum tunnelling is possible and a real factor at the nanometer scale these components operate. The chips need to mitigate the leaking charges in ways like drain channels do. The leaking electrons from even turning "cables" can crosstalk if not isolated properly.

There is a CPU in your CPU. I mean another hidden one. The Intel management engine is running on a chip that your OS is not aware of. Privileges like ring 0 is considered the ultimate power, everything the kernel has access to. Hypervisors are above that, can manage and separate multiple kernels running, side by side. We can call them ring -1 if we want to. The management engine is above that. (AMD has its own probably). And it can alter the microcode in the CPU. Also has access to the networks. Also can be powered without the CPU cores. And it's entirely proprietary and undocumented. Technically your CPU can be back doored and do stuff while your machine is turned off (but still connected to the power grid).

the iceberg: https://suricrasia.online/iceberg/

Added the ability to reference the parts created by one entity as its children. Bevy has a nice parent children relationship for this. I also added a system that moves the children whenever the parent is changed. I added an experimental life cycle system for managing growth and propagation. The children parent relations messed up the coordinate system and scaling which has to be replaced. I got really abysmal results from tremendous effort. Much ado about nothing. At least I figured out how multiple overlapping queries interplay with the borrow checker.

What do you do/ what would like to do with programming? Or is it just a hobby?

Something has to be said about the subject of the project I'm currently working on. Without revealing too much too early or being overly cryptic I can say that this is a simulation in the making. Simulated entities will be plants of some kind with simplified models of how they can grow or interact with their environment.

sneak peek:

What's something you've worked on that you're most proud of?

Most likely the demoscene intros I made (or helped to create).

For example:

So the windows build is also set up, paths of the 2 outputs are separated in the configs (even for rust-analyzer). Debugging also works.

A proof of concept system was created to figure out how the components can be manipulated and how the rendering will reflect the changes.

Some refinement was made for the system to get the correct behaviour. Another system is added which can also handle interaction between entities. Nothing too fancy yet, but it works nevertheless.

Currently planning on implementing the other systems one by one, each one building on the already working parts.

Programming pet peeve?

In others: Learn to use a debugger. I hate when people write their code and make some mistakes and ASK about what is wrong. You wrote it, find out what is wrong and fix it. What assumption you made is violated? What did you misunderstand? Why did it do THAT instead of what you expected? Debugging is a vital part of software development.

Little progress sadly, had a busy day.

Tried the graphics pipeline and of course it didn't work for the first time. Some googling yielded the solution: have to force the usage of vulkan rendering.

Now this out of the way I have the starting point to actually visually observe what the code is doing with the entities.

What kind of stuff do you like to program?

Mostly I'm interested in simulating things. Physics bodies, agents in an environment, particles, you get the idea.

Also I am interested in game development but have little experience in it.

Today's progress:

0 keystrokes 🤡

getting inspiration while walking in a botanical garden

brainstorm ideas and evaluate the viability of them

reduce scope for making an MVP and a POC

Are you self taught or were you educated in programming/computer science?

It's a bit complicated. In high school we learned Turbo Pascal and in university I had classes on the basics of programming for physicists or microcontroller programming but never had to learn the theory. I did learn some theory by myself when it came up or I was interested in it.

Had to relearn the workings of bevy. I vaguely remembered how to create systems so for most of the things I wanted to do I had to look it up in the docs or in the examples.

So far the component definitions were being worked on. Have to think about the interactions they have to start on the systems part.

Small victories.

What's your least favorite thing about programming?

Boring. Tedious. Repetitive. Mundane. Tasks.

Seriously, most of programming is at least a little bit boring. Need to connect APIs with some glue code? Have to create another special case to handle a weird edge case? Must write doxygen comments over every damn function to satisfy the project requirements? These things.

So rust was chosen and I'm very pleased with the result. I was already leaning toward using rust and learning it more along the way.

I set up the IDE of choice (vscode+WSL2) and after messing with configs and googling errors I was able to set and hit a breakpoint in a program using a dynamically linked bevy engine under the hood. Even the linting was setup to work properly which will be a huge help.

I also pimped up my terminal to look fancy as a treat.

Only thing left is writing the actual code in place of the "Hello World!".

What's your favorite thing about programming?

To be honest I like the mental challenge.