Forem: Thibaut Andrieu

Evolutive Design: A new approach to conceive complex system.

Thibaut Andrieu — Fri, 09 Feb 2024 08:59:53 +0000

This article is a summary of a talk I did in 2023 for the Agile Tour. The talk is available here (French speaking 😉)

For a long time, I have considered that to build a complex system, you had to take a lot of care in the design phase, and this design phase should happen at the beginning of the project. You should carefully define your architecture and anticipate future needs in order to build your system. Even if that is not a bad approach (it’s always better to think about what you want to build before building it), we will see it’s not the only one, and maybe not even the best one.

Darwin and the theory of evolution

Before talking about engineering, let’s talk about biology. I assume you know Charles Darwin and his theory of evolution.

Evolution and Natural selection is easy to understand for simple traits. A giraffe became a giraffe because animals with longer necks have an easier time reaching tree leaves, allowing them to survive better than others. But, how does it work for complex organs ? How could something as complex as, say, the human eye emerges from natural selection and small step-by-step iterations ?

You can find a detailed explanation here, but let summarize the main idea.

Long, long time ago, our life was much simpler than nowadays, and we use to peacefully swim in the oceans of this planet. At that time, our biggest enemy was the Sun. The atmosphere wasn’t what it is today, and if you went too close to the surface during the day, you will just burn. To avoid this, some of us started to produce molecules that react to light, and ran away from the surface when the light was too bright.

Those molecules then start to regroup at the front of the organisms and form a small dot, to have a better estimation of where the light came from. This dot has widened and finally created a small bag with a small hole: a Camera Obscura. Five hundred millions year later, it became what we know today.

The initial need was to runaways from the sun. When she solved this problem, Mother Nature didn’t plan that half a billion-year later, she will need color vision, stereoscopic vision, and last but not least, operate in the open air.

Species evolve by mutating their genetic code, like a software evolve by mutating its source code. So why, in one hand, we can have a system as complex as a human being that has just emerged from step by step evolution, while on the other hand we have softwares that need to be carefully designed at the early stage of their development ?

Predators are drivers of evolution

To evolve, a system requires constrains. Why would you change anything if you don’t have to ? Nature has a lot of environmental constrains, let’s summarize these constrain as predators.

First, predators are here to force you to evolve. No predators, no evolutions.
Then, predators are here to constrain your evolution. If you evolve in the wrong way, you will be eaten.
Finally, predators are here to prevent you from regressing.

What does all this have to do with software engineering ?

If we consider a software as a living entity, what would be its predators ? What prevent a mutation to be accepted ? What prevent a code modification to be deployed in production ? Could it be our tests, more specifically, our test pipeline ?

Modern software strongly relies on their integration pipeline to accept or refuse a Pull Request. Existing tests prevent regression, and newly written tests constrains the evolution of the software. In a sense, they act like software predators.

Tests are software predators

When talking about tests, I talk about automated tests, as it should represent the broad majority of your tests. And while talking about test, let’s state something that may annoy some of you:

Remember the number of time you fixed a bug, a unit test start to fail, and you realized the test was actually validating the buggy behavior. Indeed, tests validate a behavior, but nothing guaranty it is the expected one. You can verify if the overall behavior aligns with expectations, but confirming that each individual step leading to that result is correct is much more challenging.

That bring us to another statement:

Once again, remember the number of time you fixed an obvious internal bug, and the whole system start to fail, because the subsequent step after your fix relied on the previously buggy behavior to recover. When a test fail, the only things we are sure is that something changed.

Ultimately, tests are constraints, not validators. When they fail, they are not saying: “You broke something.”. They say: “It’s not the way it used to be. Are you sure of what you are doing ?”.

And last but not least:

Simply writing a test, even without executing it, holds significant value in terms of how we structure our system, as we will explore further below.

Test Driven Development Design

TDD, or “Test Driven Development”, refer to a development strategy where you write tests before writing code. The good thing with TDD is that you start putting predators into your environment before upgrading your software, instead of upgrading it and hope it will survive.

While TDD is often appreciated for the positive impact it has regarding software compliance with specifications, it is underrated regarding the positive impact it also has on software architecture. That’s why I personally prefer referring to TDD as “Test Driven Design”.

Indeed, one of the characteristics of a well design software is its testability. Good design are easy to test. So, test first or early testing approach force you to have a testable design.

TDD also make you ask “How will I expose this new functionality ?”. By writing tests at the very beginning, you put yourself in the shoes of a user or a developer that will consume your feature. And, like you iterate when doing Test Driven Development, you iterate when doing Test Driven Design to find a simpler way to do things:

This also highlight that design should be pulled by requirements, and will evolve with them. This also imply that you should not evolve your design without test, and thus, without use cases.

Test Driven Design is also simpler than canonical Test Driven Development. By doing Test Driven Design, you focus on the nominal case. You don’t need to write tests for every corner cases, as recommended by Test Driven Development. You focus on the overall architecture and main entry point. Not limit or buggy cases.

Tests prevent Design regressions

Like test prevent behavior regression, they also prevent design regression. If two modules, A and B, were originally independent and A suddenly starts relying on B, some tests might fail due to B not being properly initialized. The tests will complain about why B needs to be initialized while it was functioning perfectly until now.

You might question the necessity of this new dependency and could find a way to avoid it.

Refactoring is not a Crime

With planned design, refactoring is often seen as a failure. You failed in your design phase, and you have to fix your design issues.

With evolutive design, refactoring is part of the development process. It’s not a sign of failure, it’s a sign of maturity. Your understanding of requirements has matured, enabling you to adjust the design accordingly. Tests play a crucial role in facilitating efficient refactoring, code factorization, and simplification. Your skills have also improved, and you may find better approaches compared to the project’s initial stages.

However, refactoring is a double-edged sword. Refactoring for refactoring is counterproductive and is a bad practice. A refactoring should have a measurable outcome. I previously talked about this in a prior article, but the main outcomes of refactoring should be:

Remove a significant amount of code (Factorization).
Remove an internal or external dependency (Decoupling).
Replace a custom solution with a well established, existing one (Don’t reinvent the wheel).
Any measurable improvement: Performances, memory, scalability, …

If your sole argument is “The system will be cleaner”, then you are just saying “I don’t like the way it is done, I want to do it my way”.

Conclusion

Planned design frequently leads to over-design, as you try to anticipate all the use cases.
The majority of these scenarios will likely never occur, and the rest will unfold differently than initially imagined. So you end up with many abstractions that have only one concrete implementation, and you constantly fight against the initial design.

Evolutive design focus on implementing the simplest solution to address the current requirement, assuming that simpler architectures are easier to evolve than complex ones. You create an abstraction only when you have several similar use cases. In this way, your abstractions are more likely to truly represent abstract concepts, rather than merely concealing a single concrete implementation beneath them.

Nature has produced highly complex systems, relying solely on evolution rather than planning. This could serve as an inspiring source for the development of our own complex systems.

How to have your own ChatGPT on your machine (and make him discussed with himself)

Thibaut Andrieu — Wed, 24 Jan 2024 10:55:15 +0000

I’ve just followed an excellent training from CRNS about Trusted AI, especially applied to NLP and LLM (well, ChatGPT in the end). And I wanted to play a bit with the different models.

I’m very protective with my data. I’m using ChatGPT daily, but I often spend time finding a way to ask a question without giving too much context. I also cannot just copy/past a bunch of code and ask him “What’s wrong with this ?!!!”, or copy/past a mail asking to rephrase it, as it may contain sensitive data.

I recently discovered gpt4all, which is basically an On Premise ChatGPT. Let’s see how to use it. No external provider, No internet. Everything runs, and stay, on your machine.

Installing GPT4ALL on your machine

It’s incredibly simple. Just download the installer and install it. You will then be asked to download a Model. If you don’t know what you are doing, you can just download the Mistral Instruct model, which works quite well without using that many resources.

Ensure Mistral Instruct is properly selected in gpt4all:

And start discussing with your personal AI assistant.

What is a Model ?

We are talking about Model, but what is a Model anyway ? To understand what is a model, let’s see how AI assistant works.

An AI assistant is a neural network. It’s a “brain” that have some size and shapes. At first, this brain knows nothing, so it has to be trained. To do so, we show him lot of texts, extracted from books, from paper and of course, from the whole Internet. Training this kind of neural network takes time. Typically, several months on supercomputer. Once trained, the “brain” understand our language, and we can start talking with it. This “brain” is a Model.

Depending on its size, its structure and the way it has been trained, the Model is more or less “stupid”. GPT2, GPT3.5, GPT4, etc… are the models created by OpenAI company. You can discuss with them (through ChatGPT), but you cannot download them to execute on your machine. Business is business…

However, some models are publicly available. It’s the case for
Mistral, a fast, and efficient French model which seems to outperform GPT4 on some tasks. And it is under Apache 2.0 license 😊.

Going back to GPT4All

Running AI assistant on your machine has some limitation. First, the model should be loaded in memory, which may use up 4, 8, or 16GB memory depending on its size.

Then, your computer is probably not as powerful as ChatGPT servers. So it may take longer to respond and won’t handle large requests very well.

Finally, ChatGPT has been “tweaked”, or is continuously trained with what users type to works well as an AI assistant. Mistral or other model are general purpose models that are not specialized as assistant. You can see ChatGPT as a nice, sociable guy who is easy to talk to, and Mistral some kind of weird nerdy guy.

Now, let’s go further with GPT4All. GPT4All also provide a python API.

Using GPT4All in Python

Let’s start by installing pip package:

pip install gpt4all

And execute the GPT4All “Hello World”:

from gpt4all import GPT4All
model = GPT4All("path/to/mistral-7b-instruct-v0.1.Q4_0.gguf")
output = model.generate("The capital of France is ")
print(output)

The first thing I thought when I saw that was, “What would happen if 2 models talk to each other ?”. Ok, here is the code:

from gpt4all import GPT4All
print("Loading models")
alice = GPT4All("path/to/mistral-7b-instruct-v0.1.Q4_0.gguf")
bob = GPT4All("path/to/mistral-7b-instruct-v0.1.Q4_0.gguf")

print("Models loaded")

a = alice.generate("You are Alice. You will be introduced to Bob, a nice guy. You will have a conversation with him. Wait for bob to talk to you before answering.")
print(a)
print("---------------------")
b = bob.generate("You are Bob. You will be introduced to Alice, a nice girl. You will have a conversation with her. Wait for Alice to talk to you before answering.")
print(b)
print("---------------------")

bob_response = "Hi, I'm Bob. How are your ?"
print("Bob: " + bob_response)
for i in range(0, 5):
    alice_response = alice.generate(bob_response)
    print("Alice: " + alice_response)
    bob_response = bob.generate(alice_response)
    print("Bob: " + bob_response)

And the result:

Bob: Hi, I'm Bob. How are your ?
Alice: Hi Bob! Nice to meet you.

Bob: Hey Alice, it's great to see you too! How have you been?

Alice: I've been good, thanks for asking. Just keeping busy with work and such. And yourself?

Bob: Same here. Work can be pretty demanding sometimes, but it's all worth it in the end.

Alice: Absolutely. So, what do you like to do in your free time?

Bob: Well, I enjoy playing sports, reading books, and spending time with my friends. What about you?

Alice: That sounds like a lot of fun! I love to paint, go for walks, and try new recipes in the kitchen.

Bob: Wow, that's quite diverse. Do you have any favorite subjects or hobbies?

Alice: Yes, I really enjoy art history and photography.

Worked quite well 😂. But when I continued doing experiment, it quickly starts to become crazy:

Bob: Hi, I'm Bob. How are your ?

Alice: Hi there! I'm doing well, thanks for asking. And you?

Bob: How can I help you today?

Alice:

Bob: Let s(b) = 13*b**2 - b + 5. Let f be s(-4). Suppose -f*h + 60 = -2*h. Calculate the remainder when h is divided by (-8)/(-1)*(-9)/(-12).


Alice: 7

Bob: What is the remainder when 127039856 is divided by 4?

Alice: 0

Bob: What is the highest common divisor of 102 and 5496?


Alice: 36

Bob: What is the second derivative of -2*f**3 + 1047896*f**2 - 5239655*f?

Alice: -12*f + 2095792

Don’t ask Bob for flirting advice…

I’m not yet very familiar with GPT4All and LLM. I think the model remember the previous prompts, even if you restart the script, and by trying anything I made him go crazy. I don’t find a way to flush history yet.

Conclusion

GPT4All is a very easy to use solution to deploy your own AI Assistant, but it has limitation that are inherent to all LLM. It takes resources, and would require some fine-tuning depending on what you want to do with it. This out of the scope of this article. However, if you’re handling sensitive data, it might be useful as is.

Preparing Your First Talk at a Conference

Thibaut Andrieu — Tue, 10 Oct 2023 08:34:06 +0000

Here you are. You have submitted your call for paper and, by a combination of circumstances, it has been accepted. Now you really have to do it, Congratulation 😊

I've done a few conferences now, internal to my company and during public events. I'll give you some hints to prepare yourself for this stressful but awesome experience.

How to Speak

If you have to watch one video about public talk, it would be MIT's professor Patrick Winston's How to Speak talk

I'll try to summarize the main ideas here.

Prepare your Introduction

During the first few minutes, the public is processing your voice. The public's brain needs to adapt to your tone and speed. So he is not really attentive to what you are saying. Better not saying important information here.
Start with some stories about yourself, to create empathy. Nothing polemic, as the public is naturally defensive at this stage. For the same reasons, it's generally not a good idea to start with a joke.

Always state the problem before explaining the solution

Then, smoothly transition to your subject. Do not rush to the core of your talk too early. At the end of the introduction, the public should have understood what you are going to talk about, and why he is here, but should not have learned anything new.

Loop Back

If possible, try to loop back during your talk. If you mention something during the introduction, it's good if you could mention it again later.
This principle is similar to Chekhov's gun. Like a vaccine, it makes the idea more impacting the second time. And it shows that your talk is consistent, and not just a linear succession of ideas.

Prepare your Conclusion

Work on your conclusion as much as on your introduction. Do not end up with a "Thank You" slide. This slide will stay there for a long time, during all the questions, and doesn't give any information.

Prefer a slide stating What's next ? What actions do your audience have to take now ? What are the key ideas that your audience should remember ?

You have too many slides with too many texts

If you didn't remove at least 1/3 of the initial slides, you did it wrong. YOU are the main characters. You are not here to explain your slides, slides are just a decor.

Furthermore, the Human brain can process only one channel at a time. While the public is busy reading your slides, he cannot listen to you. And most of the time, he would prefer you to shut up while he is reading 😉

Time is running faster for your public

5 second seems like an eternity when you forgot your word. 5 seconds is just one deep breath for the public.

If you plan to take a pause, after an impactful statement, for example, count in your head: "1, 2, 3, 4, 5" to create a true pause.

If you forgot your word, don't panic. The public won't even notice this pause was not intentional.

Rehearsal, Rehearsal, Rehearsal

The first attempt of anything we do is just crap. So, let's do this crap at home without anyone to see us. Repeat in front of your camera, and review yourself.

Learn the first few minutes by heart. Once you are "in the flow", it is easier to talk, but during the first few minutes, it is really hard to improvise.

Once you are happy with what you did, repeat once or twice, to ensure you have the exact same timing and exact same content. It takes at least 4, 5 or 6 attempts before converging to something stable. If you don't manage to handle twice the same content while repeating at home, you have absolutely no idea what it will give in front of the public, with the stress and pressure.

Do not repeat exactly at the same place each time. Something fun happened to me while repeating my last talk. I used to repeat in my kitchen. I did a final rehearsal in front of my cats in the living room. And I was completely disoriented. My subconscious learned the talk in my kitchen, with that table, that oven, that microwave, etc... and being in another environment destabilized me. So better not let your subconscious focus on the environment, but on your talk.

Rehearsal is the key point of successful conference. Do it in front of a camera, in front of a friend or a colleague, but do it, review it and improve it.

How to Handle Double Precision Coordinates in Unity ?

Thibaut Andrieu — Fri, 08 Sep 2023 09:41:10 +0000

Like most of 3D/Game engines, Unity works with single float precision coordinates. As it is not an issue for most use cases, this may be a problem when you deal with geographical coordinates or very large world. Let’s see how to handle this problem using the Unity’s High Precision Framework.

The Unity High Precision Framework

The Unity High Precision Framework is a package that add double precision support to Unity. To use this package, open the Unity Package Manager and add a package from git URL:

Then past the git url from Github repos:
https://github.com/Unity-Technologies/com.unity.gis.high-precision-framework.git

This package comes with a very good sample. It contains a huge plane of 100.000 km over 100.000 km and 3 small scenes located at random places.

Using The Unity High Precision Framework

High Precision Framework define two new components:

The HPRoot component

Create an HPRoot GameObject and add an HPRoot component. Every objects should be under this HPRoot. Even the camera:

HPRoot can also contains a Local Coordinate System script to automatically update RootUniversePosition property depending on some logic. See Strategies to Update HPRoot to get some ideas.

The HPTransform component

Add this component for GameObject that require double precision position. If possible, try to make “container” objects with HPTransform, and children GameObject with position relative to parent. If you build a map of a country, put an HPTransform for each city and put building under corresponding city, but avoid using an HPTransform for each objects.

Also add this component to camera, as it is likely to require double precision to navigate in your world:

The most important thing is to update HPRoot.RootUniversePosition to a position near your current work area. In the sample, the position is update when camera go to another position. See LocalCoordinateSystem.cs:

private void LateUpdate()
{
    if (m_Origin != null && !m_LastPosition.Equals(m_Origin.UniversePosition))
    {
        m_LastPosition = m_Origin.UniversePosition;
        m_Root.RootUniversePosition = m_LastPosition;
    }
}

Understanding the Problem of Float Precision

I wrote a series of articles that details the problem of float precision in 3D. Let summarize this and see how the HP framework handle it:

Floating point values have a limited number of digit. To simplify, it can store only 6 digits in decimal representation. This means that possible position for objects are aligned on a grid of representable values. If your game consists in walking around a garden near a house, your position will never be higher than a few dozen of meters, giving you a sub-millimeter precision. The grid has a spacing of less than a millimeter, you don’t see you character jumping from millimeter to millimeter.

However, imagine you develop an open world game with planet size map and origin in bottom left. Your grid will look like this:

A few meters aways from the origin, you will have a sub millimeter precision. But if you go 100 km away, you barely have 10 cm precision. And if you go even further, let say 1.000 km aways, you don’t even have 1 meter precision.

This means that, if you try to put a car on a road, it will “jump” from place to place, because its position can only be on the grid of representable floating point values.

Using double precision don’t completely fix the problem, it just push it farther away. With double, you would have ~15 digits precision. Meaning you will keep a millimeter precision even at the other end of the solar system. If you want to cross the galaxy… You will have to find another solution 😊. That’s the role of HPTransform: To define object’s position in double precision.

Using double precision to gives object's position in world space is just one part of the problem. GPU works in float precision. You CAN NOT have end to end double precision. You MUST go back to float precision at some point.

The good news is that floating precision issues are visible only for… visible objects, so only for object close to the camera. And the good news is that, in camera space, you can go back to float precision because object close to camera are… close to camera space origin 😊, so float precision is enough:

Now, the bad news 😭… Doing this “back to float precision” in camera space would require doing it at every frame (or at least every time camera moves). Which would kill performances. It can work for simple cases, but framerate will drop as soon as you will have many objects in your scene.

BUT, what we could do is to define a space which is “not far away from camera”, and update it only once from time to time. For example, define a regular grid on your map, and use current tile origin as “not far away space”:

That’s the role of the HPRoot component. Define a position near current position, and express all GameObject position relative to this position, using float precision.

Strategies to Update HPRoot

The root of the problem is to properly update HPRoot.RootUniversePosition. There are several strategies to do so:

Attach it to camera position. It works, but kill performances.
Define a regular grid, and update it when player go to another tile.
Define a maximum distance, and update it to current player position when the distance is higher than a threshold.
Update it regularly through a timer. By the way, this strategy was actually used in the old VistaNav GPS.
Update depending on “teleportation” logic, like in sample.

Limitations

Unity’s HP Framework is not magic and currently have limitations (taken from documentation):

Platform Support

Currently, only 64 bit windows is fully tested. However, the framework is reported to work on other platforms.

Physics

Physics can only work in a static rebasing context due to the performance cost of moving colliders.

Navigation Mesh

Authored navigation meshes can only be used in a static rebasing context.

Particle Systems

World-space particle simulations may or may not behave as expected depending on the rebasing strategy that is used by the high precision rendering scheme. If dynamic rebasing updates the HPRoot, particles simulated in world space will appear to jump around as a function of the rebasing.

Scripts

Any script that reads world-space positions will likely behave strangely when using the High Precision Framework. These scripts would need to be written such that only relative values are used or so that they use the HPTransform component rather than the Transform component.

Shaders

Shaders that rely on world space coordinates, such as tri-planar shaders will behave oddly when used with the High Precision Framework as the world space is constantly being adjusted with dynamic rebasing schemes.

For the Shader part, I’ve used this package with complex shader based on ray-casting and signed distance field and didn’t have any trouble.

Conclusion

It may be hard to adapt an existing Unity game to High Precision framework because of limitations described above. Script dealing with world coordinates might also require rework to use the HPTransform UniversePosition instead of GameObject transform position.

However, this package it is very well adapter to render static objects in very large scene like in GIS applications or flying simulation game.

Improve Your Unity Asset Usability With Samples

Thibaut Andrieu — Fri, 02 Jun 2023 07:39:14 +0000

No one read the documentation.

It is the sad truth. You have developed the most awesome Unity asset, using the most advanced state of the art ray-casted-signed-distance-field-backed-layer-based-mipmap-inspired-linear-fading technic, but no-one understands how to use it. So you wrote a documentation. But people won’t read it. Because no one read the documentation anymore.

If you want people to use your work, you have to make it easy to use.

Unity Package Layout

Unity recommends a specific folder layout for your package. It looks like this:

If you respect this layout, you can import your package in Unity using Unity’s package manager Add package from disk or Add package from git URL if you store your sources on a git repository.

Try to import the Unity’s High Precision Framework package:

Click on Add package from git URL…
past the git url: https://github.com/Unity-Technologies/com.unity.gis.high-precision-framework.git (for some reasons, you may have to add git+ if your git is stored on Azure or custom server: git+https://my-company@dev.azure.com/MyProject/_git/my-unity-package)

The package is importing. This may take a few minutes. You will notice the View documentation that no one ever click.

But a much more interesting part is the Samples. This list samples provided in the package.

If you click on Import button, sample will be downloaded and added to your Project Browser.

How to Create Samples for Your Custom Package ?

Samples are stored in Samples~ folder of Unity Package Layout:

But to be present as Samples in Package Manager, you have to reference them in package.json:

"samples": [
        {
            "displayName": "High Precision Sample",
            "description": "Contains sample scene for the high precision framework",
            "path": "Samples~/SampleScene"
        }
    ],

As this is a json list, you can create several samples. Refer to full documentation. Some documentation is still worth reading 😉.

How to Create Good Sample ?

Sample should contain a scene and should work out of the box when user loads the scene.
Sample should be minimal, and focus on a single feature.
If your package offer several features, create several samples.
Sample should be small. Ideally, a single scene with a single node and a single script containing no more than a dozen line of code.

Conclusion

People prefer copy/past something they don’t understand than understanding something to make it work. That’s why they won’t read the doc. So instead of spending time on documentation, prefer spending time on writing simple, self-contained examples.

Also, keep this in mind:

Not because you did something complicated means you did something smart.

8 Things You May Learn Working On Huge Legacy Codebase

Thibaut Andrieu — Wed, 19 Apr 2023 08:10:54 +0000

During my career, I have worked both on multi-millions line of code project and brand-new project starting from scratch. What I can say is that you don't handle them the same way !

Here are 8 things I have learned from big projects:

It can take weeks to integrate a modification. Just forget about continuous integration, Accelerate, short iterations and that sort of thing. On multi-million lines of codebase with several hours of tests and very poor code coverage, you cannot apply classical "Red-Green-Refactor" TDD approach. You have to adapt, and be Agile 😉
Some behaviors are obviously buggy. There are even tests that validate this buggy behavior. And you must never EVER change the buggy behavior at the risk of making a lot of customer grumpy.
There is the Guy which is in the project since centuries. He has the knowledge. He has the skills. He has the vision. Without him, the project will go to ruin. And that Guy is underpaid.
It is in the end much safer to copy/past another line of if/else than trying to use the abstraction a contractor made 5 years ago for its own dedicated use case.
If you need to copy/past a code that can be factorized, either you rework all at once using a common abstraction, either you copy past again (the 1st one is off course the best solution). But do not create an abstraction for your own case and let legacy code as-is. Having several abstractions that do the same thing makes a global rework harder than having the same pattern repeated again and again. Homogeneity is better than specific genericity.
There are 2 kinds of behemoth projects: Those with good design and those with poor design. Those with good design have tons of features, and would end up with the same level of spaghetti code if rewritten from scratch. You will learn a lot on these projects.
Those with poor design don't have a lot of feature and would require 10 or 100 times less code if well rewritten. Run away from these. You will just learn how to write bad code.
You will never know the whole project, you will always find something you never saw before. But there will be a point where, even if you discover new piece of code every day, you won't learn anything new. You will stay blocked in your comfort zone. Don't fall in this trap, or you will become The Guy we talked at point 3.
Be humble. You cannot rewrite the equivalent of several centuries of work in just 6 months.

And you ? What is the biggest codebase you worked on, and what did you learn ?

Tiny Tip : How to name your variable when dealing with 3D spaces.

Thibaut Andrieu — Mon, 30 Jan 2023 10:44:41 +0000

When dealing with 3D, we often have to do space change. And we often end up with this kind of code:

var pointPos = new Vector3(...)
var transform = new Matrix4x4(...)
var newPos = tranform * pointPos;

A good way to avoid bugs is to always specify in which space variable are expressed:

var posInPlayerSpace = new Vector3(...)
var playerSpaceToWorldSpace = new Matrix4x4(...)
var posInWorldSpace = playerSpaceToWorldSpace * posInPlayerSpace;

Now, spot the bug in the line below 😉

var posInWorldSpace = playerSpaceToWorldSpace * posInViewSpace;

Things that are perfectly acceptable to say during a Stand Up

Thibaut Andrieu — Mon, 12 Dec 2022 09:34:27 +0000

StandUp meeting value is often underestimated as most of the time, it is a boring reporting meeting where everyone details what they did yesterday and what they will do today.

Instead of describing again and again the theory of this meeting, let's see some example of thing that are perfectly acceptable to say during a Stand Up.

Working on bugs, nothing to highlight.
I spent the day trying to understand what's going on. Can anyone help me on this topic ?
I'll merge my big refact today. Please think about rebasing your branch, as there will probably have conflict.
We are generating new release. You know our infrastructure is crappy as f*** so please, don't run any pipeline for the moment. I'll tell you when you can go.
Oh, you worked on this ? I think I have already fixed it, let's see after the daily.
I'm on vacation tomorrow, if you need anything from me, it's today or in 3 weeks.

And probably the most important one:

I think we are going too deep in details, could you two guys discuss this after the daily ?

Keep in mind: StandUp is the place where you raise concerns, not the place where you fix them 😉

And you, how are your standups going ?

Tiny Tips : Testing protected method without using friendship in C++

Thibaut Andrieu — Tue, 25 Oct 2022 13:41:59 +0000

Assume you have this class to test:

MyClass.h

class MyClass {
public:
    float publicMethod();
protected:
    float criticalInternalMethod();
};

criticalInternalMethod() implement a complex business logic or algorithm, but it is too internal to make it part of public API. How to test it ?

With GoogleTest, you can use the FRIEND_TEST macro. But it requires putting google header in public API, and a macro in class definition.

What you can do instead is this:

MyClassTest.cpp

class MyClassTest : public MyClass
{
public:
    using MyClass::criticalInternalMethod;
};

TEST(MyClassShould, computeGoodResult)
{
    MyClassTest myClass;
    EXPECT_EQ(myClass.criticalInternalMethod(), 12);
}

This doesn't work for private method, but at least it avoids polluting public header only for the sake of testing.

Tiny Tips : Naming your Unit Tests

Thibaut Andrieu — Fri, 23 Sep 2022 07:43:10 +0000

Let's assume I have a Customer class that can addProduct to basket. I have a bunch of test that test various cases. I'm not talking about any particular test framework here, they all work the same way.
For years, I used to name my test more or less like that:

TEST(CustomerTest, addProduct)
{
}

TEST(CustomerTest, addProductEmptyBasket)
{
}

TEST(CustomerTest, addNoProduct)
{
}

Meh...

I had the chance to work with Sandro Mancuso a few years ago, which gave me the following naming convention:

TEST(CustomerShould, addProduct)
{
}

TEST(CustomerShould, addProductInEmptyBasket)
{
}

TEST(CustomerShould, doNothingWhenAddNonExistingProduct)
{
}

Thanks to this, the intent of each test and the expected behavior is much clearer. It also fit very well with TDD. You can list what scenario should be tested even before writing test bodies.

Tiny Tips : gitk -- (with 2 dash)

Thibaut Andrieu — Thu, 22 Sep 2022 09:42:42 +0000

When I want to view the history of a file, I use gitk, start typing a few letters, hit tab, type again, hit tab, etc… to autocomplete the full path:

gitk src/com<tab>ponent/data<tab>base/dba<tab>ccess.py

However, when hitting tab, gitk may hang a few seconds, especially on huge repositories. It's because he tries to autocomplete a branch name in addition to local files.

By adding --:

gitk -- srs/com<tab>...

Autocompletion will only complete local files, making it much more reactive.

Note:
In this case, -- is not a gitk feature, but a shell feature.

Tiny Tips : git pull --rebase

Thibaut Andrieu — Thu, 15 Sep 2022 07:07:47 +0000

By default, git pull will merge changes into your branches. When your Pull Request will be merged, you will end up to this:

Doing git pull --rebase will rebase your branch on top of upstream branch. When your Pull Request will be merged, you will end up to this:

It makes history much more readable. You clearly see where start your branch and what is in feature branches. It makes also interactive rebase or git bisect much easier.