I spent some time before discussing with her some of the basics concept verbally: the different parts of a computer, and basic elements of procedural programming languages (variable, condition, loops).

And recently, I proposed to practice and code something on the computer together. She was reluctant at first I guess the lectures I gave her before lost her haha.

So I decided to make a small game first to pique her interest 😯

I gave a quick thought and came up with that direction:

• A small text game we can play in console (something I could finish in an hour)

• I would be using Ruby (the least boilerplate possible and elegant code for beginners)

• The game code would be one file only and linear as much as possible to be easy to read almost like a story with exit points where the player loses (easy to read)

• I would use some variables, conditions and one loop to show her actual usage of them (something not too complex to introduce complexity step by step)

• And to show her a text game can still be cool I would add some awesome ASCII arts 😎

After about an hour I had a game ⌚

You are an adventurer who just arrived in a city which has been claimed by a terrible dragon who is now living in the castle of the local king.

It’s cliché but simple enough for her to understand and me to come up with a story quickly.

The dragon game 🐲

Avatar

It’s a text game, but I still wanted to have a bit of incarnation for the player so that when she tries my game it would be citing her name.

So the code starts with that:

puts "Welcome adventurer, start by entering your name:"

name = ask

clear_screen

puts "Very well, #{name} ! We need your help.. \n"

We have one variable: name and I hid some of the complexity thanks to Ruby, by defining a function ask and clear_screen in another file that I wouldn’t show to her.

def ask 
  print "> "
  return gets.chomp
end

def clear_screen
  system('clear') || system('cls')
end

A good example of simplification of the reality

Once you entered your name, a character describes the awful situation with the dragon, and ask you to confirm if you are capable of helping them.

The code looks like that:

puts "Are you capable of defeating the dragon ? (yes or no)"

choice = ask

if choice == "no" 
    print "Ah !? "
    sleep(3)
    print "What a shame..."
    sleep(3)
    puts " thanks anyway. Farewell #{name}."

    exit
end

print "Super !"
sleep(1)
print " Super ! "
sleep(1)
puts "We are saved !"

There are several things interesting here.

• First we are using a condition the first one so she can a practical example of a condition

• Second we use that condition to exit early the game: game over we lose, thanks to exit

• Third we use sleep(n) to give a bit of tension in the text showing up piece by piece. Combined with print which allows us to keep writing on the same line unlike puts

• Fourth, an important thing that I discussed with my daughter for a while, we are simplifying the choice! Something we often do in game development or software in general. We do choices on how much of abstraction to use to represent the reality. We have to manage our time, resources to allocate them to the main feature, the main element that will end with the best experience. Hence sometimes creating illusions. Illusion of choice. Thus here, the player answers no, we stop the game. The player says anything but no, the game continues. Obviously we could try to convert the input from the player to lowercase to catch even uppercase, use a regex, or even test for the player input against ”yes” with a loop. But nothing of that would serve or improve really the experience of the game!

The hard part: a loop

puts "Hint: 48 + 21 - 5"
sleep(1)
puts "You are trying to enter a code:"

code = -1

while code != 64
    code = ask_number

    if code != 64 
        puts "It does not work, try something else..."
    end
end

We needed a loop to put in practice what I discussed with her. Here I went with a mathematical operation that the player needs to solve and until the player didn’t give the right answer he can try. We could have may be write it a bit more nicer without the condition inside, but again limited time, so it’s good enough.

Some others conditions

The game continues after with several tough situations where the player has to pick the right decision and we test that using several conditions. To alternate and go a bit further into conditions, I also decided to create a situation with 3 choices, only one winning. By using a if/else if condition.

puts "The dragon starts breathing fire strongly towards you ! Quick, what do you do ?"

puts "  1. You jump on the left side to avoid the flames."
puts "  2. You use your shield made in dragon skin."
puts "  3. You hide yourself behind a box on your right side."

choice = ask_number

if choice == 1
    # Some specific bad end 
    puts "..." 
    puts "Game Over \n"

    exit
elsif choice == 3
    # Another specific bad end 
    puts "..."
    puts "Game Over \n"

    exit
end

It is interesting I believe to show her that conditions can be more complex. In her game we also used if choice == 1 || choice == 3 showing again an example of a more complex condition and a simplification of the game to allocate more resources on the rest of the game too.

Adding juice

My first draft of my game did not have any ASCII art, but after I thought it would be nice to add a bit of juice, or show her something cool in the middle of the game to break the pattern (https://lawsofux.com/von-restorff-effect/).

So here is an example of a very cool ASCII dragon I found online (thanks to joan stark and IronWing for their art) that I included in my game.

def dragon_fire 
  puts "                                       \\/"
  puts "                                       ^`'."
  puts "                                       ^   `'."
  puts "             (                         ^      `'."
  puts "           )  )        \\/              ^         `'."
  puts "         (   ) @       /^              ^            `'."
  puts "       )  )) @@  )    /  ^             ^               `'."
  puts "      ( ( ) )@@      /    ^            ^                  `'."
  puts "    ))  ( @@ @ )    /      ^           ^                     `'."
  puts "   ( ( @@@@@(@     /       |\\_/|,      ^                        `'."
  puts "  )  )@@@(@@@     /      _/~/~/~|C     ^                           `'."
  puts "((@@@(@@@@@(     /     _(@)~(@)~/\\C    ^                              `'."
  puts "  ))@@@(@@)@@   /     /~/~/~/~/`\\~`C   ^             __.__               `'."
  puts "   )@@@@(@@)@@@(     (o~/~o)^,) \\~ \\C  ^          .' -_'-'\"...             `."
  puts "    ( (@@@)@@@(@@@@@@_~^~^~,-/\\~ \\~ \\C/^        /`-~^,-~-`_~-^`;_           `."
  puts "      @ )@@@(@@@@@@@   \\^^^/  (`^\\.~^ C^.,  /~^~^~^/_^-_`~-`~-~^\\- /`'-./`'-. ;"
  puts "       (@ (@@@@(@@      `''  (( ~  .` .,~^~^-`-^~`/'^`-~ _`~-`_^-~\\         ^^"
  puts "           @jgs@             (((` ~ .-~-\\ ~`-_~`-/_-`~ `- ~-_- `~`;"
  puts "          /                 /~((((` . ~-~\\` `  ~ |:`-_-~_~`  ~ _`-`;"
  puts "         /                 /~-((((((`.\\-~-\\ ~`-`~^\\- ^_-~ ~` -_~-_`~`;"
  puts "        /                 /-~-/(((((((`\\~-~\\~`^-`~`\\ -~`~\\-^ -_~-_`~-`;"
  puts "       /                 /~-~/  `((((((|-~-|((`.-~.`Y`_,~`\\ `,- ~-_`~-`;"
  puts "      /              ___/-~-/     `\"\"\"\"|~-~|\"''    /~-^ .'    `:~`-_`~-~`;"
  puts "     /         _____/  /~-~/           |-~-|      /-~-~.`      `:~^`-_`^-:"
  puts "    /    _____/        ((((            ((((      (((((`           `:~^-_~-`;"
  puts "    \\___/                                                          `:_^-~`;"
  puts "                                                                    `:~-^`:"
  puts "                                                                  ,`~-~`,`"
  puts "                                                                 ,\"`~.,'"
  puts "                                                               ,\"-`,\"`"
  puts "                                                             ,\"_`,\""
  puts "                                                            ,\",\"`"
  puts "                                                         ;~-~_~~;"
  puts "                                                          '. ~.'    "
end

If you want to check out the game of my daughter and the dragon one I made, 🔎

Their entire code is available here: https://github.com/SonnyAD/mini-games

Note that the games are in French though. So feel free to translate or simply reuse the structure to practice programming with your kid too.

To conclude

I think that mini text game has been a good introduction to programming and she liked it. So it’s a success I believe. Since that day, we did another session where we added a rock, paper, scissors mini-game inside the game of my daughter. And we will be adding more and more complexity step by step.

This article is a follow up on my previous one introducing the concept of SE Spectrum:

Existing solutions

For long, the easiest way to run a spectrum was to use visual drawing or diagram tools like Miro, Google Drawing, Excalidraw, or any equivalent. One, generally the host would prepare a setup with different space labeled from “Strongly disagree” to “Stronly agree”. Then while running the spectrum, people would duplicate or create a small pellet to represent their position visually.

And it would look like that:

On top of that we would run a voice conferencing tool, like Google Meet, Zoom, Discord, StreamYard, etc.

Pain points 🤒

• These tools are generally for collaborations and everybody has the rights. We often end up modifying or deleting the pellet of someone else by mistake.

• You need to go back and forth the diagram tool and the voice conferencing to move your positions or mute/unmute yourself.

• It requires a bit of setup to prepare your spectrum.

• Often all these tools requires you to sign up and login adding even more friction to start and invite participant in your spectrum (Excalidraw is the best one on that point).

This is where I decided to contribute and make a dedicated software for Spectrum

So let me introduce to you OSR Spectrum!

It is an application dedicated to running spectrums online. It was initially made for the French non-profit organization “Opinions sur Rue” (OSR) promoting Street Epistemology in France, but I recently added English translation and the software is now ready to welcome more users!

Features

• Can start or join a spectrum with between 2 to 6 participants

• No collision, everyone controls only his own pellet

• Each spectrum has its own private room/link to share to participants

• Integrated text chat including history of the spectrum (positions, new claims, ...)

• Integrated voice calls too (still a bit chunky though)

• Possible to connect to a live stream chat to get an average vote of the viewers (platforms supported: YouTube, Twitch, and TikTok)

• Send emoji reactions or raise hand with an animation alike Zoom, Google Meet, and others

• Streamer mode to optimize UI for screen sharing

• Localized in English and French

• Respect of privacy, nothing is stored it's all in ephemeral memory database. And no login/password.

• Open Source software, you can run your own instance

Software Goal 🎯

It's made to be usable as is without the need for anything else thanks to the chat and voice calls included. But you can still definitely use it as you want, if you prefer to use Discord voice channel or StreamYard etc. Opinion sur Rue uses it with StreamYard.

How to use it?

1. Find participants

2. Go to https://spectrum.utile.space

3. Click on “Start a Spectrum”

   

4. Fill your nickname and optionally an initial claim

   

5. Once started, click on “Copy Link” and send the link to the participants

   

6. Once they joined, they can start to move their pellets and the spectrum is ready to go

7. Optionally, you can activate voice conferencing

   

8. During the spectrum, also everybody can send emoji or raise hand

   

Links

If you want to see how it looks in real conditions 🔎

Here is a video from one of the online Spectrum ran by “Opinions sur Rue” (sorry it's in French though ^^):
👉 https://youtu.be/4JkX0n7C7bU?t=2031

If you want to run your own instance, or contribute, here is the GitHub repository 🌐

👉 https://github.com/Opinions-sur-Rue/spectrum

If you just want to run a spectrum or test the app 🧪

You can freely use the instance I am running at: https://spectrum.utile.space/

I am looking for more users and feedback to continue to debug and improve it 🤗

So if you have feedback, please go to https://spectrum.utile.space and on the top right, there’s a link to submit feedback through a google form

Cover picture source: https://www.youtube.com/watch?v=_0ysPb44C28

First of all, welcome inside this new awesome rabbit hole I found which is Street Epistemology and today in that new article we’re going through Spectrum.

🧠 What is a Spectrum?

A spectrum is an adaptation of Street Epistemology, a technique rooted in the Socratic method that uses thoughtful questioning to examine the foundations of one's beliefs. In a spectrum, participants physically position themselves along a spectrum line to indicate their level of agreement or disagreement with a given statement. This visual representation facilitates open dialogue and helps individuals understand the diversity of perspectives on complex issues.

🎯 Objectives of a Spectrum

• Encourage critical thinking and self-reflection on personal belief.

• Foster respectful and meaningful conversations among individuals with differing viewpoint.

• Develop skills in active listening and constructive dialogue.

• Promote understanding and empathy through shared exploration of idea.

🛠️ How It Works

1. Statement Presentation: A facilitator introduces a thought-provoking statement for discussion.

2. Physical Positioning: Participants stand along a spectrum line that represents a range of agreement or disagreement with the statement.

3. Dialogue and Exploration: Through guided questions and discussions, participants share their reasoning, challenge assumptions, and consider alternative viewpoints.

4. Reflection and Adjustment: As the conversation progresses, individuals may choose to adjust their position on the spectrum, reflecting a shift in their perspective based on the dialogue.

⚠️ Consideration

Engaging in a Spectrum requires a willingness to openly express one's beliefs and to respectfully consider differing opinions. Participants should be prepared for the possibility of standing alone in their viewpoint and should feel comfortable with public discourse.

For a practical demonstration of a Spectrum, you can watch the following video:

If you are not using GitHub there are alternatives including the open source version of Dependabot (https://github.com/dependabot) or also Renovate: https://www.mend.io/renovate/

But in this article I will not go through the configuration of any of them. I wanted to share my experience. I have been using for Dependabot for a couple of years now and I think the following advice should apply to any equivalent alternatives.

• Never merge any Dependabot’s PRs right away!

• It’s tempting but we should check a few things before.

• First of all you need a CI workflow that will run on every PR push. And you should check whether it did run successfully or not.

• That workflow I suggest to be at least checking formatting, linting, and confirm build/compiling still works. Ideally we have tests too.

  • You can find an example for a Svelte front-end here: https://github.com/SonnyAD/utile-front/blob/main/.github/workflows/pr.yml

• In the case the PR did not pass, pretty often (from my experience) it's a minor thing to fix/migrate. Generally you can see from the lint or build errors what is not compiling anymore. So checkout the branch of the PR locally do the fix yourself in the branch and commit/push, once the PR workflow passes then you can consider merging it.

• In the rare case where things need a huge migration, I suggest considering to delay that migration until you have proper time and focus for it. Or you can just decide to stick to the current version. For the latter, you can add something like below in the dependabot.yaml. The example makes Dependabot stick with any 20.x.y version for @types/node:

    ignore:
      - dependency-name: '@types/node'
        versions:
          - '>=21.0.0'

• After merging, in some cases, especially if you don't have much test coverage, an update can bring an unwanted behavior that you notice later. At that moment, don't hesitate to come back to the merged PR, and click on the Revert button in it and merge right away the reverting changes

Final pieces of advice

Generally it's better to stay on latest versions of your dependencies. Because they likely have less bugs, are more performant, have up-to-date documentation (not always true), etc.

But you don't need to rush updates too.

Plan regular time to process the dependabot PRs. And better update dependencies days ahead of releases (if you don’t apply CD and/or don’t have enough tests) because of the unwanted behavior we can notice sometimes later.

Updating dependencies is an ongoing (never-ending) maintenance work. But I believe that if you apply all the advice, it will make your products last longer too.

Photo by Harli Marten on Unsplash

As long as I remember I have always been interested by skepticism. And I think one element that really resonated with me has been that conference talk by Phil Plait:

15 years later I would still recommend a watch today.

I think that motto: “Don’t be a dick” stayed with me ever since. It was not easy while spending time on Twitter. I have probably been a dick several times over there. And I only remember one and only one good interaction on Twitter. I believe it was because my interlocutor at that time really tried to understand me, and I was giving him the same treatment.

What is this blog about?

“Street Epistemology” (SE), it’s only after hearing at least dozens of times about the concept that I decided to investigate. At that time, the reference everybody was pointing at was the videos from Anthony Magnabosco.

At first I didn’t like his videos TBH. The topic is often about religion which is not my cup of tea. But after retrying a couple of times, I started to notice how easily Anthony could speak of tough subjects like religious belief with anybody on the street. And that without an ounce of conflict, all in peace. Without being a dick…

So what is Street Epistemology?

It is a set of techniques and a practice to conduct a pleasant conversation with someone while discussing some of his important beliefs. The conversation is asymmetric, each side plays a specific role.

The roles

The « questioner »

The "questioner" guides the conversation. Their first goal is to create a calm and welcoming space where their partner feels safe expressing their deeply held beliefs. Without this, SE is impossible!

The second goal is to understand their partner’s ideas by asking step-by-step questions. Success is achieved when the questioner can summarize the other person’s thoughts as clearly as if they were their own.

Finally, the questioner’s last goal is to provide critical perspective. They help their partner articulate their ideas, reflect on their statements, and even strengthen their arguments. There is no notion of winning or losing—regardless of the outcome, both parties benefit.

The « interlocutor »

As for the interlocutor, they express their opinion. Around 70% of the speaking time is dedicated to them, and only their perspective is discussed—the questioner’s opinion is discouraged. If the interlocutor asks for the questioner’s view, it should be shared only at the end of the conversation. This approach helps prevent much of the tension.

The Five Steps of an SE conversation

Building Rapport

Establishing a friendly connection usually takes less than five minutes. Rushing straight to the point to save time would be a mistake—genuine interest in the other person, sharing personal experiences, and finding common ground are valuable. This time is essential for fostering self-reflective thinking while making the conversation both productive and enjoyable.

Consent to discuss a sensitive topic must always be obtained explicitly, even with close acquaintances. Pressuring someone, even unintentionally, undermines trust. Maintaining a positive atmosphere is crucial—if consent wavers or the mood deteriorates, it should be addressed immediately.

Focusing on the Key Argument

This process consists of three steps. Initially, the topic may be vaguely defined, so some time is spent refining a statement that truly reflects the interlocutor’s core belief. Next, the arguments supporting this belief are listed. Finally, the key argument—the one carrying the most weight for the interlocutor—is identified.

Identifying the Epistemology

This step involves clarifying the process or method the interlocutor uses to support their key argument. It may be based on personal experience, an authoritative source, scientific consensus, tradition, intuition, faith, or other reasoning.

Testing the Epistemology

This is the most delicate phase, as the goal is not to counter-argue but to help the interlocutor find their own counter-arguments. They are encouraged to consider questions they may not have asked before: Are my ideas internally consistent? How could my belief be proven wrong? In what situations? Using what methods?

An experienced questioner guides the interlocutor toward such reflections without imposing their own views. It is not uncommon for the questioner to change their own perspective based on the discussion. The most rewarding moments are often marked by long, thoughtful silences, followed by “That’s a good question” or “I don’t know.”

Conclusion

An SE conversation can be mentally demanding for both participants. When possible, the questioner aims to conclude on a positive note, even if not all objectives are met.

Paradoxically, while changing one’s mind takes time, the best conversations last under twenty minutes, often leaving a sense of unfinished business. The goal is to spark deep reflection over several days, until the next discussion. Moreover, concluding an interview does not mean closing the conversation—the questioner remains available to share and challenge their own beliefs, at least as an act of reciprocity.

Source: Jason Bloch, Tanguy Robyr, and Charlie Tétillon from the non-profit organization “Opinion sur Rue” promoting SE in French

How to learn and practice it

So aside obviously the resources I already mentioned, now in 2025 I would recommend:

• The book “How to Have Impossible Conversations” from Peter Boghossian. He is an American philosopher and college professor. And he is the main person who developed Street Epistemology methodology during the 2000s through field experiments and academic research. He refined his method by incorporating insights from psychology, negotiation, and deradicalization. His book from 2019 remains the key reference on the method.

  

• The free online course from Street Epistemology International non-profit organization led by Anthony Magnabosco:
  https://navigatingbeliefs.com/

  

• But if you are a French speaker, I would strongly recommend the free 9 weeks training from the non-profit French organization called “Opinions sur Rue” https://www.opinions-sur-rue.fr/
  I had the chance to take their training in 2024 and it was great. Also their Discord community is pretty active and easy-going.

  

But why am I talking about SE on a blog mostly about software engineering?

Well, for many reasons.

Polarization on social networks and in our modern society is a big problem. And us software engineers are part of the problem, and part of the solution too. So I believe there is inspiration to take from a tool like Street Epistemology and to apply to our software to help understanding each other and improving the search of consensual solutions instead of division.

As an engineering manager as well, we all run 1 on 1 meetings with our collaborators. And I think there are few things from SE that we should also use as well:

1. Embrace silences. We tend to avoid silence, thinking time is money and that we should make the most of the meeting time but just don’t do that. Silences are an important to leave room for thinking things through.

2. Use active listening. Let your collaborator express himself, your main goal during these 1 on 1 is to understand what you can do to help him/her. So you need to hear him/her and check if you really understood him/her by rephrasing his/her thoughts.

One last thing: Spectrum.
Spectrum is a derived practice from Street Epistemology also from Peter Boghossian, where multiples person participate to a conversation about their belief on a specific claim and standing physically on a paper representing their position from Strongly Agree to Strongly Disagree.

In a spirit of contributing to the movement of SE for better discussing on the Internet, I started to develop an online tool to run a Spectrum online. The team at “Opinion sur Rue” has been using it for some time now. And I want to share more details about it in future blog articles. So stay tuned.

Ok so, how to compute Pi?

We are in 2024, so the first thing I did is to ask our favorites LLMs to help me with the code.

I tried ChatGPT, Claude, and some others… They all provided me an algorithm… that was not working. And even trying to debug the algorithms with them by reporting errors and such. It was a dead end…

Then I went on Google, I didn’t find anything precisely in Go. So I think we can assume the LLMs were trained on the same data that is not containing a solution for that. Hence they were hallucinating an algorithm mixed on others solution and Go code they learnt.

No LLMs then! Let’s use Human Intelligence…

After reading the wikipedia page of Pi, one of the algorithm mentioned to compute Pi is called Chudnovsky Algorithm.

I am not going into the explanation of the algorithm here, so if you want more details I invite you to check out the wikipedia page about it:

https://en.wikipedia.org/wiki/Chudnovsky_algorithm

The good thing here is that the page provides a Python code to compute it! So now I just need to convert that code to Go!

Converting Python code to Go code

To be honest, I tried again LLMs at that stage to see if they could help…

They were of no help again… except one thing. Thanks to ChatGPT I learnt that the sort of equivalent of the decimal module of Python in Go is math/big.

From now I took the simplest approach to reach my goal: I copy pasted the Python code and converted by hand to Go line by line.

About 20 lines of Python code and mostly math calculation so it’s not that long and complex.

We have a chudnovsky function that takes one argument n which will stop the convergence to Pi. Again this is the formula from Chudnovsky below.

$$\pi =\lim _{n\to \infty }{\frac {426880{\sqrt {10005}}\cdot Q(1,n)}{13591409Q(1,n)+R(1,n)}}$$

Inside the chudnovsky function we then call the recursive function binarySplit.

Challenges of the conversion

The first major difference with Python I encountered has been that Golang does not provide operator overloading. So while in Python is pretty clean using * and / it was not possible with Go and the package math/big.

For instance * has to be replaced by a call to .Mul(x, y) and + by .Add(x, y).

Two others operators in Python gave me a bit of trouble.

Cube

In Python the line is:

Qab = 10939058860032000 * a**3

Looking at the math/big https://pkg.go.dev/math/big#Float I didn’t see any Power function. So I ended writing this simple version of a Cube function for this type:

func cube(v *big.Float) *big.Float {
    result := newBigFloat(1)
    result.Mul(result, v)
    result.Mul(result, v)
    result.Mul(result, v)
    return result
}

If it would have not been a power of 3, I would have probably written a loop. But here I believe this is clear and simple enough. Most important it does the job!

Floor division

In Python the line is:

m = (a + b) // 2

I didn’t know about this operator, and it exists in some others languages. You can find the details here:

But in two words, as its name says, it divides a by b and then floor the result. So in an other word, it’s a Euclidean division.

The good thing here is that as long as my numerator and denominator are integer in Go, the classic / operator is a Euclidean division in Go.

So the conversion simply became:

m := (a + b) / 2

After that, I noticed something was off

For the moment, I disregarded the Python line:

decimal.getcontext().prec = 100 # number of digits of decimal precision

This is a convenient way in Python to change the precision of the big float you are manipulating.
And after reading the big.Float from Go, I noticed that by default they only 53 digits of precision:

NewFloat allocates and returns a new Float set to x, with precision 53 and rounding mode ToNearestEven.

So while I am trying to compute a result of at least 10K decimals, using something with only 53 digits is pretty pointless…

Another annoying thing is there is no one-liner like Python. So I came up with a factory to create my big.Float with the right precision set in advance.

func newBigFloat(v float64) *big.Float {
    return big.NewFloat(v).SetPrec(floatPrecision)
}

All the pieces of the puzzle were now more or less complete now!

And then Pi!

3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632788659361533818279682303019520353018529689957736225994138912497217752834791315155748572424541506959508295331168617278558890750983817546374649393192550604009277016711390098488240128583616035637076601047101819429555961989467678374494482553797747268471040475346462080466842590694912933136770289891521047521620569660240580381501935112533824300355876402474964732639141992726042699227967823547816360093417216412199245863150302861829745557067498385054945885869269956909272107975093029553211653449872027559602364806654991198818347977535663698074265425278625518184175746728909777727938000816470600161452491921732172147723501414419735685481613611573525521334757418494684385233239073941433345477624168625189835694855620992192221842725502542568876717904946016534668049886272327917860857843838279679766814541009538837863609506800642251252051173929848960841284886269456042419652850222106611863067442786220391949450471237137869609563643719172874677646575739624138908658326459958133904780275900994657640789512694683983525957098258226205224894077267194782684826014769909026401363944374553050682034962524517493996514314298091906592509372216964615157098583874105978859597729754989301617539284681382686838689427741559918559252459539594310499725246808459872736446958486538367362226260991246080512438843904512441365497627807977156914359977001296160894416948685558484063534220722258284886481584560285060168427394522674676788952521385225499546667278239864565961163548862305774564980355936345681743241125150760694794510965960940252288797108931456691368672287489405601015033086179286809208747609178249385890097149096759852613655497818931297848216829989487226588048575640142704775551323796414515237462343645428584447952658678210511413547357395231134271661021359695362314429524849371871101457654035902799344037420073105785390621983874478084784896833214457138687519435064302184531910484810053706146806749192781911979399520614196634287544406437451237181921799983910159195618146751426912397489409071864942319615679452080951465502252316038819301420937621378559566389377870830390697920773467221825625996615014215030680384477345492026054146659252014974428507325186660021324340881907104863317346496514539057962685610055081066587969981635747363840525714591028970641401109712062804390397595156771577004203378699360072305587631763594218731251471205329281918261861258673215791984148488291644706095752706957220917567116722910981690915280173506712748583222871835209353965725121083579151369882091444210067510334671103141267111369908658516398315019701651511685171437657618351556508849099898599823873455283316355076479185358932261854896321329330898570642046752590709154814165498594616371802709819943099244889575712828905923233260972997120844335732654893823911932597463667305836041428138830320382490375898524374417029132765618093773444030707469211201913020330380197621101100449293215160842444859637669838952286847831235526582131449576857262433441893039686426243410773226978028073189154411010446823252716201052652272111660396665573092547110557853763466820653109896526918620564769312570586356620185581007293606598764861179104533488503461136576867532494416680396265797877185560845529654126654085306143444318586769751456614068007002378776591344017127494704205622305389945613140711270004078547332699390814546646458807972708266830634328587856983052358089330657574067954571637752542021149557615814002501262285941302164715509792592309907965473761255176567513575178296664547791745011299614890304639947132962107340437518957359614589019389713111790429782856475032031986915140287080859904801094121472213179476477726224142548545403321571853061422881375850430633217518297986622371721591607716692547487389866549494501146540628433663937900397692656721463853067360965712091807638327166416274888800786925602902284721040317211860820419000422966171196377921337575114959501566049631862947265473642523081770367515906735023507283540567040386743513622224771589150495309844489333096340878076932599397805419341447377441842631298608099888687413260472156951623965864573021631598193195167353812974167729478672422924654366800980676928238280689964004824354037014163149658979409243237896907069779422362508221688957383798623001593776471651228935786015881617557829735233446042815126272037343146531977774160319906655418763979293344195215413418994854447345673831624993419131814809277771038638773431772075456545322077709212019051660962804909263601975988281613323166636528619326686336062735676303544776280350450777235547105859548702790814356240145171806246436267945612753181340783303362542327839449753824372058353114771199260638133467768796959703098339130771098704085913374641442822772634659470474587847787201927715280731767907707157213444730605700733492436931138350493163128404251219256517980694113528013147013047816437885185290928545201165839341965621349143415956258658655705526904965209858033850722426482939728584783163057777560688876446248246857926039535277348030480290058760758251047470916439613626760449256274204208320856611906254543372131535958450687724602901618766795240616342522577195429162991930645537799140373404328752628889639958794757291746426357455254079091451357111369410911939325191076020825202618798531887705842972591677813149699009019211697173727847684726860849003377024242916513005005168323364350389517029893922334517220138128069650117844087451960121228599371623130171144484640903890644954440061986907548516026327505298349187407866808818338510228334508504860825039302133219715518430635455007668282949304137765527939751754613953984683393638304746119966538581538420568533862186725233402830871123282789212507712629463229563989898935821167456270102183564622013496715188190973038119800497340723961036854066431939509790190699639552453005450580685501956730229219139339185680344903982059551002263535361920419947455385938102343955449597783779023742161727111723643435439478221818528624085140066604433258885698670543154706965747458550332323342107301545940516553790686627333799585115625784322988273723198987571415957811196358330059408730681216028764962867446047746491599505497374256269010490377819868359381465741268049256487985561453723478673303904688383436346553794986419270563872931748723320837601123029911367938627089438799362016295154133714248928307220126901475466847653576164773794675200490757155527819653621323926406160136358155907422020203187277605277219005561484255518792530343513984425322341576233610642506390497500865627109535919465897514131034822769306247435363256916078154781811528436679570611086153315044521274739245449454236828860613408414863776700961207151249140430272538607648236341433462351897576645216413767969031495019108575984423919862916421939949072362346468441173940326591840443780513338945257423995082965912285085558215725031071257012668302402929525220118726767562204154205161841634847565169998116141010029960783869092916030288400269104140792886215078424516709087000699282120660418371806535567252532567532861291042487761825829765157959847035622262934860034158722980534989650226291748788202734209222245339856264766914905562842503912757710284027998066365825488926488025456610172967026640765590429099456815065265305371829412703369313785178609040708667114965583434347693385781711386455873678123014587687126603489139095620099393610310291616152881384379099042317473363948045759314931405297634757481193567091101377517210080315590248530906692037671922033229094334676851422144773793937517034436619910403375111735471918550464490263655128162288244625759163330391072253837421821408835086573917715096828874782656995995744906617583441375223970968340800535598491754173818839994469748676265516582765848358845314277568790029095170283529716344562129640435231176006651012412006597558512761785838292041974844236080071930457618932349229279650198751872127267507981255470958904556357921221033346697499235630254947802490114195212382815309114079073860251522742995818072471625916685451333123948049470791191532673430282441860414263639548000448002670496248201792896476697583183271314251702969234889627668440323260927524960357996469256504936818360900323809293459588970695365349406034021665443755890045632882250545255640564482465151875471196218443965825337543885690941130315095261793780029741207665147939425902989695946995565761218656196733786236256125216320862869222103274889218654364802296780705765615144632046927906821207388377814233562823608963208068222468012248261177185896381409183903673672220888321513755600372798394004152970028783076670944474560134556417254370906979396122571429894671543578468788614445812314593571984922528471605049221242470141214780573455105008019086996033027634787081081754501193071412233908663938339529425786905076431006383519834389341596131854347546495569781038293097164651438407007073604112373599843452251610507027056235266012764848308407611830130527932054274628654036036745328651057065874882256981579367897669742205750596834408697350201410206723585020072452256326513410559240190274216248439140359989535394590944070469120914093870012645600162374288021092764579310657922955249887275846101264836999892256959688159205600101655256375679

Here is Pi up to 10K decimals, that you can get here too: https://utile.space/math

It’s computed dynamically each time. 10K is the reasonable of digits that my server can compute in a reasonable time.

For the fun, I computed 1M decimals too

As just I said, 10K is somehow the limit of my server, but I wanted to go bigger.

I chose to run the computation locally on my computer, with enough precision and let the thing run for 10-15 minutes. Then saved the result in a file.

Thanks to it, you can also access of the first 1M on utile.space by clicking on Lazy load π 1M first decimals.

Technically via a pagination system, you will browse that file I computed on my computer to read the 1M in your browser page by page. IIRC 10K decimals per page.

I didn’t realize before but 1M digits it’s very long…

Hey wait! What about Tau?

Yeah, right! If you don’t know about Tau I invite you to read the Tau manifesto first!

Here: https://utile.space/pdf/tau-manifesto.pdf

In shorts, the main idea is that we often need 2*Pi , not Pi itself. So instead let’s use Tau which is equal to 2*Pi

One Tau radians angle is a full circle. Half of Tau of Half a circle.

A bit more logical, isn’t it?

And for the code for it I used the most simple and readable one:

func ChudnovskyTau(n int) *big.Float {
    pi := Chudnovsky(n)
    pi.Mul(pi, newBigFloat(2.0))

    return pi
}

Conclusion, what’s next?

What I retained personally from the experience:

• It demonstrates again that (current) LLMs are a mirror of the current knowledge available on internet

  • I haven’t tried the latest LLMs designed towards reflection and construction of a train of thoughts. I might have some surprise with it.

• I got to know the math/big package in Go.

• I also implemented a websocket server for the purpose of serving the 1M digits of Pi in lazy loading fashion. That websocket that I am going to experience more and more with to create interactive experience.

What’s next? Well the Chudnovsky algorithm I have is single-threaded. From my understanding there are possibilities of parallelizing some of the computation, likely here:

Pam, Qam, Ram := binarySplit(a, m) // on one thread
Pmb, Qmb, Rmb := binarySplit(m, b) // on another

So I might come back to that later. I might also try to compute more digits. To server 10M, 100M, 1B digits of Pi. But not sure yet. Because it represents challenges in terms of size 1B represents 1G and computation time.

At the end of the blog, I was promising to follow up and describing my journey... Today September 2nd, 2024, the website is now at its version 4.5.0....

So we can fairly say that I failed at documenting that project.

Let's be honest I probably over promised...

I tend to be curious and try a lot of things as you probably guessed when going through my blog. So between work, hobbies, family, and more, blogging was always at the bottom of my todo list.

Let's try to repair the situation!

Even if, I need to say it's truly a pity. Because I did face some challenges on my way that I think would have been interesting to share.

For example, I started my front-end with Dart but I quickly gave up. It was three years ago so my memory around that decision is not that fresh. But IIRC I reached a dead-end where I was lacking something to help me binding values between my UI and my view models. I briefly started to build something alike Angular Dart... And quickly felt like I was rewriting the wheel.
I took a step back and decided to give up on Dart.

Anyway, let's just break the spell and I won't over promise or promise anything at all. I just hope I can share some interesting stuff to you in the near future.

For the curious ones, my website link: https://utile.space and the GitHub repos: https://github.com/SonnyAD/utile-compose

I held a conference to introduce the different careers inside the gaming industry to high school students, and that presentation is a summary of it.

ℹ️ This blog article is for you if you are willing to work in the video game industry, but you are not sure how yet.

Who am I?

Sonny Alves Dias

• 🖥 Software engineer
  Master's degree from l'Université de Technologie de Belfort-Montbéliard in France

• 🕹 10 years in the video game industry
  Mostly doing development and production of video games

• 🇨🇳 9 years in China
  Shanghai and Guangzhou

• 🛠️ Skills
  Web, Unity, DevOps, Backend, IA

Foreword

The gaming industry is composed of multiple company types including:

• Individuals : Jonathan Blow, Lukas Pope, ...

• SMEs : Motion Twins, Hello Games, Asobo Studio, ...

• Up to big companies and multinational groups : Don't Nod, Ubisoft, Nintendo, ...

In the latter ones, you will have a specific job role and work on your expertise. While in SMEs, you will have multiple job roles and work on your versatility.

Some definitions

• Visual Effects (VFX)

• Sound Effects (SFX)

• User Interface (UI)

• User Experience (UX)

• Quality Assurance (QA)

• Game engine

Specialties List

A) Graphics
B) Audio
C) Technical
D) Marketing
E) Test / QA
F) Localization
G) Production
H) Design
I) Support

A) Graphics

Graphic artist

The graphic artist or illustrator in video games creates graphic elements to enhance the game's aesthetics, including characters and environments. Working with design teams, they use specialized software to bring their creations to life, contributing to the game's visual identity.

• Concept artist

• Character designer

• Environment artist

• 2D Games

• Marketing

VFX Artist

The VFX artist in the video game industry is responsible for creating and implementing digital visual effects such as explosions, fire, and magical effects. By collaborating with development teams, they use specialized software to bring these elements to life, contributing to the game's immersive aesthetics.

3D Modeler

The 3D modeler in video games creates three-dimensional models for characters, objects, and environments, contributing to visual quality and immersion. Using specialized software, they collaborate with development teams to build the game's virtual world.

UI/UX designer

The UI/UX designer in video games designs the user interface (UI) and user experience (UX). Their role is to create intuitive and aesthetic designs, collaborating with development teams to ensure a smooth and immersive gaming experience.

Animator

The animator in the video game industry is responsible for bringing characters, objects, and actions in the game to life by creating animations. Using specialized software, they contribute to the players' immersion in the virtual world. Their work is essential for creating visually dynamic and captivating gaming experiences.

Video Editor

The video editor in the video game industry is responsible for assembling and editing video sequences to create coherent and attractive content. In collaboration with production teams, they use editing software to structure the game's visual elements, including cinematic and trailers, ensuring a smooth and impactful visual narrative for players.

B) Audio

SFX artist

Le SFX artiste dans le jeu vidéo crée et intègre les éléments sonores, tels que bruitages et musiques, pour améliorer l'expérience audio du jeu. En collaboration avec l'équipe de développement, ils utilisent des outils spécialisés pour donner vie aux mondes virtuels, contribuant ainsi à l'immersion des joueurs.

C) Technical

Gameplay Programmer

The gameplay programmer in the video game industry develops the code that governs the interaction and functionality of the gameplay. In collaboration with game designers, they translate ideas into lines of code, ensuring a smooth gaming experience that aligns with the game's vision.

Engine Programmer

The engine programmer in the video game industry focuses on developing the game engine, handling essential aspects such as graphics, physics, and performance optimization. In collaboration with development teams, they write code to improve the engine's efficiency and ensure a solid foundation for game creation.

Backend/Server Programmer

The backend programmer in the video game industry develops the server logic and databases to ensure the functionality of online features. Working closely with development teams, they write code to manage server-client interactions, ensuring smooth and reliable multiplayer experiences.

DevOps Engineer

The DevOps engineer in the video game industry facilitates collaboration between development and operations teams. Their central role involves automating deployments, monitoring performance, and ensuring continuous integration. By optimizing operational efficiency, they help ensure the stability of game infrastructures for a smooth user experience.

IT manager

The IT manager in the video game industry oversees IT operations, ensuring the security, availability, and efficiency of systems. In collaboration with teams, they define technology strategies, ensure project implementation, and contribute to the smooth functioning of the game's technological environment.

D) Marketing

Marketing is responsible for promoting games to the target audience and maximizing their visibility in the market. Their mission involves developing effective marketing strategies, including advertising campaigns, promotional partnerships, and launch events. They work closely with development teams to identify the game's unique features and create compelling messages to attract players. The marketing department also analyzes market trends and player feedback to adjust promotional strategies and optimize business results. In summary, their goal is to raise awareness of the games and boost sales while strengthening the company's brand in the video game industry.

Here is a non-exhaustive list of jobs related to video game marketing.

• Marketing Director/CMO

• PR relations

• Social media manager

• Community manager

• Influencer/Content creator*

• Writer and copy writer*

E) QA

The QA (Quality Assurance) department in a video game development or publishing company is responsible for ensuring the quality and reliability of games before they are released to the market. Their mission involves thoroughly testing every aspect of the game to detect bugs, glitches, and performance issues. They conduct functional, compatibility, and localization tests to ensure the game is playable, stable, and suitable for different systems and languages. The QA department works closely with development teams to report identified issues and ensure they are resolved before the game is published. In summary, their goal is to guarantee a smooth and satisfying gaming experience for players.

Here is a non-exhaustive list of jobs related to video game marketing.

• Game tester

• Localization tester

• QA engineer

F) Localisation

Chef de projet localisation

The localization project manager in video games coordinates the translation and linguistic adaptation of the game for different markets. By working with teams, they ensure the cultural and linguistic adaptation of the game, providing a consistent experience for a global audience.

G) Production

Producer

The producer in the video game industry oversees the overall development of the game. Responsible for planning, coordinating, and monitoring the project, they work with development teams to ensure deadlines, budget, and creative vision are met. Their role is crucial in guaranteeing the quality and success of the game by effectively managing all production phases, from design to release.

H) Design

Game Designer

Game design involves creating the rules, mechanics, and systems that define the gaming experience. Game designers envision the game's worlds, characters, and challenges, working with the development team to bring them to life using design tools. Their goal is to create engaging and balanced interactive experiences for players.

• Game Director

• Game Designer

• System Game Designer

• Technical Game Designer

Level Designer

The level designer creates the levels and playable environments in a video game, placing game elements to offer interesting challenges and an immersive experience for players.

Narrative Designer

The narrative designer creates the story, characters, and dialogues of a video game, seamlessly integrating them into the gameplay to provide an immersive narrative experience for players.

I) Support

There are also, of course, several important roles that are common to all types of businesses and industries. Here is a non-exhaustive list below.

• Executive Assistant

• Administrative Secretary

• Legal Advisor, Lawyer

• Human Resources Manager

• Chief Financial Officer

• Payroll Manager

• etc.

Some Advice

• If you have a passion for video games, it's a good starter, but this is not enough!

• Entering the industry can be difficult :

  • A portfolio can greatly help you

  • An internship

  • Use your network

• Conditions inside the industry are improving but still pay attention to:

  • Crunch problems

  • Sexism and any inclusion problems

• Being able to speak English is a must

One day you migrate to AWS Route53 because you want geolocation, load balancing, or something of the sort. And disaster! There is no web redirection.

With this article, you will know how to solve that and set up a serverless web redirection at a low cost and a little effort.

Steps

1. Lambda

Please find below an example of a NodeJS lambda:

export const handler = async(event) => {
    const res = {
        statusCode: 301,
         headers: {
            Location: 'https://example.com'
        }
    };
    return res;
};

and Python

def lambda_handler(event, context):

    return {
        "statusCode": 301,
        "headers": {
            'Location': "https://example.com"
        }
    }

2. API Gateway

• Select a REST API (**not Private **)

• In the next page,

  • confirm REST API, not Websocket

  • create a New API

  • give it a name like web-redirection

  • endpoint type select Edge Optimized

• In the API detail page,

  • Click on Actions and select Create Method

  • Select GET method under the path / and confirm

• In the / GET method details,

  • Select the lambda you created in the first section and save.

• Finally, publish the API by clicking on Actions > Deploy API

  • Enter a stage name for your deployment something like production

3. Custom Domain Name

• Still in the API Gateway service, click on Custom Domain Names

• For each domain you want to redirect, Create a Custom Domain Name

  • Select Edge Optimized to match the API Gateway we created above

  • And select (or create) a certificate that matches the domain

• Once created, setup API mapping to the API gateway we created before with no path required

4. CloudFront

• Go to CloudFront and create a distribution

• Do not define any alternate domain, and no certificate

• For the origin enter the API gateway endpoint and specify for the origin path /prod as the stage name you defined earlier

5. Route53

• Add a Route53 record on the domain

• And point at the CloudFront from the previous section

Conclusion

Go to your domain example.net and validate that the redirection to example.com is working!

• Game Over screen with scoring and retry button
• Finalizing the notes balancing and rhythm

But it’s not completely finalized yet, and will continue working on both.

I thought though it would be nice to make an article about building the game for WebGL and sharing a link to play the game in its current state!

🌐How to make a WebGL build?

First, you need to install the tool from Davidobot: https://github.com/Davidobot/love.js

npm install -g love.js

Web server with proper headers

Then you will need a server and a web server running on it. On my end, I use Nginx, and this is how I configured my location:

location /beathoven/ {
        add_header Cross-Origin-Opener-Policy same-origin;
        add_header Cross-Origin-Embedder-Policy require-corp;
        alias /usr/share/nginx/html/beathoven/;
}

Add missing mime type

After several tries looking at errors in browser, I realize also I needed to edit the file /etc/nginx/mime.types to add the definition for wasm file:

    application/vnd.google-earth.kmz      kmz;
    application/wasm                      wasm;
    application/x-7z-compressed           7z;

Use 7zip not tar on Windows

To package your game into a love file, you need to simply zip the files.

And since Windows 10, it includes a tar command line utility that you can use to make zip in scripts. But it looks like it’s not supported by the WebGL build. So I switched to 7Zip using the following parameters:

You can also use 7zip in command line.

My Build & Deploy script

And this is what I ended up with to build and deploy my game on demand:

#!/bin/bash

tools/7za a -tzip Beathoven.zip assets/ gameobjects/ pages/ responsive/ utils/ fonts.lua main.lua -mx0
mv Beathoven.zip Beathoven.love

love.js -t Beathoven -c Beathoven.love game 

ssh server rm -rf /usr/share/nginx/html/beathoven/*

scp -r game/* server:/usr/share/nginx/html/beathoven/

🎮 Where to test the game:

Now that I am able to build and deploy the game, here is the link to test it: https://utile.space/beathoven/

Conclusion

Don't hesitate to give feedback on the game in the comments. Or let me know if you would like to give a hand.

Next steps are going to finalize the retry function of the game, which I started a big refactor for it. And I want to improve the UI then with animations and such.

Instead of using a piano like controller, I wanted to use something a bit more like those music arcade game with button spread around the screen.

And I went with 4 buttons spread as a diamond. 4 buttons means 4 fingers game play, which sounds not too overwhelming, but still fun.

Some screenshots

Current features

• Splash screen
• Title screen
• Timer before actual rhythm game starts
• Gameplay with 4 buttons (tracks) with instant pressed notes only
• Scoring at each right note
• HP reducing at each wrong note
• Note streaking tracking with different messages at different levels

Planned features/work

• Game Over screen with scoring and retry button
• Finalizing the notes balancing and rhythm
• Adding more animation in the UI
• Game responsive
• Game introduction
• Better particles effects
• Long notes with kept-pressed buttons

🤝 Some sharing

It’s difficult to reduce multiple hours and several thousands lines of code in one blog article, so I’ll share a couple of things.

📬 Tracks’ queue

In order to save the notes currently on the track of a button, I made this Queue class (based on the classes.lua I shared in my last article.)

local classes = require "classes"

local Queue = classes.class()

function Queue:init()
    self.first = 0
    self.last = -1
    self.items = {}
end

function Queue:count()
  local count = 0
  for _ in pairs(self.items) do count = count + 1 end
  return count
end

function Queue:enqueue(value)
    self.last = self.last + 1
    self.items[self.last] = value
end

function Queue:dequeue()
  if self:count() == 0 then
    return nil
  end

  local first = self.first
  local value = self.items[first]

  self.items[first] = nil        -- to allow garbage collection
  self.first = self.first + 1

  return value
end

function Queue:deleteFirst(value)
  local i = -1
  for k = self.first,self.last,1
  do
    if self.items[k] == value then
      self.items[k] = nil
      i = k
    end
  end

  -- Value not found
  if i == -1 then
    return
  end

  for k = i,self.last,1
  do
    self.items[k] = self.items[k+1]
  end
  self.items[self.last] = nil
  self.last = self.last - 1
end

function Queue:print()
  local res = "Queue: { "
  for k,v in pairs(self.items) do
      res = res..k..": "..v..", "
  end  
  print(res.." }")
end

return Queue

When I press a button, a note is dequeued, and we check if the note was overlapping the button. If it was, then it’s a success and if not, then it’s an early miss.

🥁 Beat Finder

A rhythm game means playing with the rhythm/beat of a music.

In order to do that, I could think of several solutions:

• Using Fast Fourier Transformations on the sound data to detect high frequencies peak and put a note at that moment
• Using the 5th symphony partition
• Using a tool like Audacity to automatically detect the beat

I went with the latter, knowing that I would still have a lot of manually editing to do, to make things fun.

If you load a sound in audacity, you can click then on Analyze > Beat Finder

This will add a label track with a label on each beat detected. You can export it then File > Export > Export Labels. It’ll provide you a text format easily parsable.

Conclusion

If you were looking to making a rhythm game on your own, I hope that my findings can help you to get kick-started quickly. If you are interested in Beathoven and/or would like to participate in the dev, let me know. For now, the game is not open source, but once I am happy with the state of the code and game I’ll share it.

I will keep updating this guide from your feedback and the continuation of my exploration of LÖVE. Last update on October, 6th 2022.

Recently I decided to spend a bit of time exploring LÖVE on my spare time. It uses Lua as programming language. And is an open-source engine available for free on Windows, Mac, and Linux. You can also build your game for iOS/Android and even Web.

Website: https://love2d.org/

I thought it would be easy coming from Unity and different others languages. But it took me a bit of time to find the information or logic behind the language and engine.

So I decided to write this guide to help you get kick-started and easily transitioned to LÖVE.

Guide

Lua Language

Here are some examples of different things you may want to use:

Important Links

• Programming language reference: Programming in Lua https://www.lua.org/pil/contents.html

• Package manager for Lua: LuaRocks https://luarocks.org/

Variables

local x = 1 -- Only available in local scope
globalVar = 2 -- Global variable

Usual Operations

-- increment variable
i = i + 1

-- decrement variable
i = i - 1

-- concatenate the variable name with two strings
message = "Hello, my name is "..name.."!"

-- not equal operator (others are the same as others languages)
test = something ~= 0

-- logical operatiors: not, and, or 
test1 = not something
test2 = something and somethingelse
test3 = something or somethingelse 

-- tertiary operator (a ? b : c)
test = a and b or c

Note: there is no i++ in Lua to increment.

If, elseif, else

if playerJumped then 
  -- Start jump animation
elseif playerCrouch then 
  -- Start crouch animation
else
  -- Play idle animation
end

For Loops

-- Loop over i from 0 to 20 and increment by 1 at each cycle 
for i = 0,20,1
do
  -- Do something
end

Note: you cannot have multiple variables in the for statement. If you need multiple variables look at doing a while loop instead.

While Loops

local i = 0
while i < 20
do 
  -- Do something 
  i = i + 1
end

Functions

function f(argument1) 
  return something * argument1
end

Note: all the primary types (numbers, boolean, nil, strings) are passed by values, everything else is passed by reference to the function.

Anonymous Functions

Inline argument

do(function()
    print("Hello!")
end)

Variable

myfunc = function(n)
    return n*n
end

-- example of call
myfunc(5)

-- example of use as argument
do(myfunc)

Classes and OOP

There is a native way of doing it, using the official language reference: https://www.lua.org/pil/16.1.html

But I found a bit inelegantly and the function setmetadatatable is confusing.

So I found another solution that simplifies the code you need to write to create classes and child classes: https://gist.github.com/paulmoore/1429475

You only need to import the file classes.lua in your project, but definitely look the examples.

But here is a quick example.

-- Load the classes helper file
local classes = require "classes"

local Enemy = classes.class() -- Create a class without any parent

Enemy.count = 0

function Enemy:init(name)
    self.hp = 100
    self.name = name
  Enemy.count = Enemy.count + 1
end

-- static function
function Enemy.count()
  return Enemy.count
end

local Orc = classes.class(Enemy) -- Create an Orc who is an enemy

function Orc:init(name, weapon)
  self.super:init(name) -- call to parent constructor
    self.weapon = weapon
end

-- Instantiate some orcs 
local orcWithAxe = Orc.new("Zotor", "Axe")
local orcWithBow = Orc.new("Plead", "Bow")

Notes:

• We use new to instantiate and define init in the class, which is called implicitly during the new operation.

• For static methods and variables, use the class name followed by a . then the name of the element you want to access.

• For object methods and attributes, use the variable name followed by a : then the name of the element you want to access.

• For private methods, don’t prefix the name of the function with the name of the class.

Queues and Stacks

For that I made a module based on the example provided by the official language reference. https://www.lua.org/pil/11.4.html

List = {}
function List.new ()
  return {first = 0, last = -1}
end

function List.count(l)
  return #table
end

function List.pushleft (list, value)
    local first = list.first - 1
    list.first = first
    list[first] = value
  end

  function List.pushright (list, value)
    local last = list.last + 1
    list.last = last
    list[last] = value
  end

  function List.popleft (list)
    local first = list.first
    if first > list.last then error("list is empty") end
    local value = list[first]
    list[first] = nil        -- to allow garbage collection
    list.first = first + 1
    return value
  end

  function List.popright (list)
    local last = list.last
    if list.first > last then error("list is empty") end
    local value = list[last]
    list[last] = nil         -- to allow garbage collection
    list.last = last - 1
    return value
  end

return List

Copy that in a file list.lua in your project. Then you can use that way:

queue = List.new()
stack = List.new()

-- Enqueue values
List.pushright(queue, someValue)
List.pushright(queue, someValue)
List.pushright(queue, someValue)

-- Stack values
List.pushleft(stack, someValue)
List.pushleft(stack, someValue)
List.pushleft(stack, someValue)

-- Consume queue (FIFO)
local value1 = List.popleft(queue)
local value2 = List.popleft(queue)

-- Consume stack (LIFO)
local value3 = List.popleft(stack)
local value4 = List.popleft(stack)

Arrays and Tables (structured data)

Table is specific type in Lua, it’s a bit like arrays in PHP which can be associative or indexed.

-- same initialization
local array = {}
local table = {}

-- initializing array values
for i = 0,20,1
do 
    array[i] = i
end

-- initialization table values
table["x"] = 0
table["y"] = 0

-- or could be done at the declaration
local coords = {x=0, y=0}

Cron

If you want to schedule a specific action at a certain time, you want to use cron/timer. The easiest solution I found is to use the tool made by kikito: https://github.com/kikito/cron.lua

local cron = require 'cron'

local function printMessage()
  print('Hello')
end

-- the following calls are equivalent:
local c1 = cron.after(5, printMessage)
local c2 = cron.after(5, print, 'Hello')

c1:update(2) -- will print nothing, the action is not done yet
c1:update(5) -- will print 'Hello' once

c1:reset() -- reset the counter to 0

-- prints 'hey' 5 times and then prints 'hello'
while not c1:update(1) do
  print('hey')
end

-- Create a periodical clock:
local c3 = cron.every(10, printMessage)

c3:update(5) -- nothing (total time: 5)
c3:update(4) -- nothing (total time: 9)
c3:update(12) -- prints 'Hello' twice (total time is now 21)

LÖVE Engine Specifics

OK, Lua itself requires some learning as you’ve seen. But LÖVE too!

Important Links

• Official documentation: LÖVE Wiki https://love2d.org/wiki/Main_Page

Structure

To run a game you need a folder with a main.lua at least.

Example of minimal structure:

function love.load()
    -- Run once at game initialization
end

function love.keypressed(key, scancode, isrepeat)
    -- Run each time a key on the keyboard is pressed
end

function love.mousepressed(x, y, button, istouch, presses)
    -- Run each time a mouse button is pressed, supports multi-touch too
end

function love.update(dt)
    -- Run at each frame before drawing it
    -- This is where you handle most of your game logic
end

function love.draw()
  -- Called at every frame to draw the game
end

Note: There are others functions you may need you can find the details here: https://love2d.org/wiki/love

IDE

I advice you to use Visual Code with the extension https://marketplace.visualstudio.com/items?itemName=SK83RJOSH.love-launcher

Also add a file conf.lua at the root of your folder, with that contents:

function love.conf(t)
    t.console = true
end

Now each time you press Alt+L, your game will pop plus the console window which can help to debug.

Manipulate the Game Window

You can change the default window display attribute during load of your game. Example:

function love.load()
    love.window.setMode(800, 600, {resizable=true, minwidth=400, minheight=300})
end

Details: https://love2d.org/wiki/love.window.setMode

SVG Files

I found a nice package that add supports of SVG files to LÖVE. It is called TÖVE.

Details: https://github.com/poke1024/tove2d

No active development since a couple of years ago, so be aware of that. But for me it worked fine.

Fixed Update

If you want to make your game at a constant framerate, it’s not possible natively.

But I found that gist from Leandros: https://gist.github.com/Leandros/98624b9b9d9d26df18c4 that just does the job perfectly.

You need to copy/paste the code at the end of your main.lua and that’s it. Constant 60FPS.

You can tweak the FPS if you need.

ECS (Entity Component System)

LÖVE is not natively using the paradigm ECS. But if you like ECS like I do, I found a tiny ECS framework for it. It was written in 2016, pretty old already, but it’s that tiny that it did age well.

Here is the link about: https://github.com/bakpakin/tiny-ecs

If you want to use it there’s only one file tiny.lua to copy to your project.

You can find a project using it here as example: https://github.com/bakpakin/CommandoKibbles

Post Processing Screen VFX

If you want to have some post processing screen virtual effects, the easiest I found is to use moonshine: https://github.com/vrld/moonshine

It contains 16 effects like glow, vignette, crt, .. that you can chain as you want and change parameters on the fly.

If you want to create your own effect you will have to start write shaders and extend moonshine effects.

Check the github README to understand how to use it.

Screen Shake Effect

I found on the forum of LÖVE a reply from vrld that does the job: https://love2d.org/forums/viewtopic.php?p=193765#p193765

local t, shakeDuration, shakeMagnitude = 0, -1, 0
function startShake(duration, magnitude)
    t, shakeDuration, shakeMagnitude = 0, duration or 1, magnitude or 5
end

function love.update(dt)
    if t < shakeDuration then
        t = t + dt
    end
end

function love.draw()
    if t < shakeDuration then
        local dx = love.math.random(-shakeMagnitude, shakeMagnitude)
        local dy = love.math.random(-shakeMagnitude, shakeMagnitude)
        love.graphics.translate(dx, dy)
    end
end

Game distribution

If you want to distribute your game, your starting point is the wiki at that address: https://love2d.org/wiki/Game_Distribution

More details on WegGL

First, you need to install the tool from Davidobot: https://github.com/Davidobot/love.js

npm install -g love.js

Web server with proper headers

Then you will need a server and a web server running on it. On my end, I use Nginx, and this is how I configured my location:

location /beathoven/ {
        add_header Cross-Origin-Opener-Policy same-origin;
        add_header Cross-Origin-Embedder-Policy require-corp;
        alias /usr/share/nginx/html/beathoven/;
}

Add missing mime type

After several tries looking at errors in browser, I realize also I needed to edit the file /etc/nginx/mime.types to add the definition for wasm file:

    application/vnd.google-earth.kmz      kmz;
    application/wasm                      wasm;
    application/x-7z-compressed           7z;

Use 7zip not tar on Windows

To package your game into a love file, you need to simply zip the files.

And since Windows 10, it includes a tar command line utility that you can use to make zip in scripts. But it looks like it’s not supported by the WebGL build. So I switched to 7Zip using the following parameters:

You can also use 7zip in command line.

Example of build & deploy script

#!/bin/bash

tools/7za a -tzip Beathoven.zip assets/ gameobjects/ pages/ responsive/ utils/ fonts.lua main.lua -mx0
mv Beathoven.zip Beathoven.love

love.js -t Beathoven -c Beathoven.love game 

ssh server rm -rf /usr/share/nginx/html/beathoven/*

scp -r game/* server:/usr/share/nginx/html/beathoven/

Conclusion

Obviously I haven’t covered everything here, but I hope that it can give a nice introduction to help you getting quickly productive with LÖVE and create some cool games!

Next week I’ll share about a Rhythm game called Beathoven I decided to make while exploring about the possibilities of LÖVE.

I admire the quality of their work.

• They polish their games very well!
• Their games have very few bugs.
• They perfect the gameplay of their games through generations, like Mario.
• But they take risks and try new things, like making an open world with Zelda Breath of the Wild.
• They focus on the game experience, offering their best in gaming every time.

To me, Nintendo has truly been the most significant actor in video games. They helped to democratize video games with their Famicom. And nailed the mass adoption with the Wii and more recently the Switch.

It's very exceptional that a company is by itself defining and representing a whole industry.

From the POV of a company executive

On top of their longevity, I am impressed by their courage and vision.

• They launched the Game Boy while its hardware was already obsolete, somehow. But making a huge success with it because of its cheap price, autonomy, and good catalog of games.
• After the Nintendo 64, their competitors entered a race for the most powerful consoles. While they stuck to their vision and principles, which lead to their success with the Wii.
• Since ever, they always had two major hardware products at any time: a home console and a portable console. They made the bet of creating a hybrid product: the Switch, both a home and portable console, and met success with it!

They take risks and sometimes met failures. Like with the Visual Boy, the Game Cube, or also the Wii U. But still, find the resources to rebound and change the game.

What I retain from Nintendo

• User-centric vision
• Taking risks to try new things
• While reusing and perfecting the existing

A bit of context, diplomas are different in France. I was somehow in a Bachelor in Computer Science degree at that time. And moving to that university would have been for a Master’s degree.

What happened

All my teachers were behind me and happy to refer me to this prestigious school. Only one student from our school had been accepted in the past. Would I be the second?

I passed the initial round of selection, which was a written essay on why I wanted to go to the school. And it was enclosed with a couple of reference letters from teachers.

For the second round, they included different tests and would be in person. It was about two hours drive from home. And I didn't have a car.

My sister proposed to drive me. Problem, the interview was starting at 7.30 am (that's early...). So she proposed to host me for the night too and drive me at 5 am.

When it comes to sleep, whenever I don't sleep at home in my own bed, it's difficult.

And of course the night before, at my sister's house, I was also excited and stressed by the interview. That much that I think, I fell asleep only at 2 or even 3 am.

At 4.30 am, we woke up.

At 5 am, we left the house and took the road.

At 7 am something, we arrive at the interview location. We were a bit in advance.

Problem, I couldn't sleep in the car either and with my sleep deprivation, I was like a drunkard.

I entered the room and passed these different tests. While I was completely disinhibited and over-confident from the lack of sleep.

There were some written tests: computer science and math, which were ok.

Then some group work, where I took the lead and completely silenced my group mates.

During the final interview, me alone facing a board of examiners, I declaimed some stupid things...

Going out of the room, lucidity came back, I knew I failed...

Conclusion

So my advice to everyone preparing for an interview, do your best to arrive there in the best conditions. Rent a hotel if needed, not like me...

And in the end, if you fail, it is completely ok. There are tons of opportunities! And not going to that university definitely did not kill my career in software.

Analysis

Pros

• Pretty art and graphics.
• Animation and original voices from the show!
• Energy system, limiting your kid to spend hours in the game.
• Ads system not too intrusive! And appropriate ads (This is a big plus to me).
• Possible to play the game entirely for free.
• Fun to play with your kids.
• The hint system that unblocks your kids on-demand.

Cons

• Very limited free colors choice on the freestyle drawings.

Conclusion

Here is a game that distinguishes itself from the numerous lame and scammy games you can find on the mobile app stores!

The game looks good. The concept is simple and relaxing. It uses well the touch screen. The game has good limitations so that your kid doesn't spend hours on it. While not forcing your hand to pay for it and having ads that are not that much intrusive.

A game I recommend to other parents! Congrats to Budge Studios for this one.

Links

• Google Play
• Apple Store

I am renewing the operation this year, and to be straightforward with you

I gave up on Alacritty

Alacritty is nice, but in daily life there were a lot of frictions (that are maybe fixed by now TBH) especially for copy/pasting string into the shell. Also, IIRC no tabs or such.

So what am I using now?

I switched to Hyper! It's an electron-based terminal made by Vercel, the company that offers this platform to greatly ease the deployment of an app. I recommend Vercel and glitch.com also if you want to deploy a small or website easily.

Download link: https://hyper.is/

To make Hyper work with the usual Git Bash, I changed that line in the configuration:

        shell: 'C:\\Program Files\\Git\\bin\\bash.exe',

And to directly copy selected text to clipboard, I changed that line to true:

        copyOnSelect: true,

I didn't change much more aside the font.

New year, new font

Last year I recommended Fira Code. This year I would recommend you Monoid an open source coding font, more details there: https://larsenwork.com/monoid/

Other suggestions

• If you want an easy way to install and uninstall software from the command line on Windows, check out chocolatey.org
• If you use Git Bash and Docker like me, you probably want to add that line to your ~/.bashrc:

  alias docker='MSYS_NO_PATHCONV=1 docker'
  

  That will allow you to do things like: docker exec -ti ${CONTAINER} /bin/bash directly from Git Bash.
• Also, if you use one of the latest Git Bash, there's a bug that creates troubles when you ssh into a server. Symptoms are like you can't use vi or CTRC+C will quit the entire ssh session. Add the following line in your ~/.bashrc as well, and it will fix it.

  export MSYS=enable_pcon
  

Disclaimer: this is an introduction and it does not cover everything obviously. And I simplified some explanations on purpose.

As a prerequisite, if you are not familiar with Bitcoin, you should read my introduction to Bitcoin here:

*Special thanks to Sosthene for proofreading my article and his feedback! Follow him on Twitter. *

Let's start now! And to discuss Liquid, we need to discuss first: Elements.

What is Elements?

It is a fork of Bitcoin extended to be a sidechain platform with these features:

• Confidential Transactions

• Issued Assets

• Federated 2-Way Pegs

• Signed Blocks

• Additional opcodes

Source: https://elementsproject.org/

OK, whatever, but what’s Liquid?

• Well Liquid is an instance of Elements. Set as a sidechain of Bitcoin and maintained by Blockstream.

• It is managed by a static federation of 15 members, but soon dynamic.

• It is configured to have a block time of 1 minute.

• And its main currency is L-BTC (Liquid Bitcoin), the result of the pegging of Bitcoin.

More details: liquid.net

What are the features of Liquid?

Let’s see a bit more details on the different features of Liquid/Elements.

2-way pegging of Bitcoin

Peg-in

Pegging in BTC from the Bitcoin mainnet into the Liquid sidechain consists of depositing BTC into the Liquid Bitcoin wallet that is managed by the Federation. 102 confirmations on the Bitcoin mainnet are then required for you to claim your amount of L-BTC due, and the functionaries then grant you the corresponding amount on the Liquid sidechain.

Peg-out

Pegging out BTC from the Liquid sidechain back into the Bitcoin mainnet consists of receiving the BTC from an anonymous functionary from his wallet after being granted the amount by the federation.
2 confirmations on Liquid are required for the operation to be allowed. Then the Federation will co-sign a transaction out of their 11 of 15 multisig wallet that is sending out the amount requested to one of the functionaries described anonymously. Finally, the functionary processes the transaction that will grant the BTC to the requester of the peg-out.

🙈 Confidential Transactions

• Amounts and assets are blinded using a blinding key, but UTXOs are visible

• There is a master blinding key that is generated from the wallet seed and derived as needed for each address:

blinding_private_key := HMAC_SHA256(key=master_blinding_key, msg=script_pubkey)

where script_pubkey corresponds to a specific non-confidential public address you want to make confidential

• That means that a Liquid wallet consists of two things: an extended private key and a master blinding key.

• Also, every confidential address is a non-confidential address blinded using the master blinding key. So the confidentiality is essentially a layer built on the top of classical HD wallets.

• Note that you can dump a specific blinding key to allow a tier to unblind it using the RPC unblindrawtransaction. And once in possession of the blinding key, any transaction happening with that specific address will be visible to the tier.

  FYI Blockstream Green has a feature to open esplora with the blinding keys to allow a tier to see a confidential transaction unblinded on the web.

White Paper: Blockstream

Specifications: Satoshi Labs

💰 Issued Assets

• One asset on Liquid/Elements has these attributes (all saved in the blockchain):

  • An asset ID (generated by Liquid)

  • A total supply

  • An optional reissuance key

  • An optional contract hash

• Reissuance keys are also an asset that comes with at least a total supply of 1 sat

• L-BTC is also an asset, a special one that can be pegged in and out: Details

• The bare minimum to issue an asset:

elements-cli issueasset 0.00000100 0

-> It issues a confidential asset with a total supply of 100 satoshis and no reissuance key.

• The contract defines metadata about the asset like its name, ticker, domain owner, precision, etc. Example the EXOeu token:

{
 "entity": {
  "domain": "exordium.co"
 },
 "issuer_pubkey": "030cff26f9c0d365f090e24917277e23269d7ef5d7f06dec9f09de9255b8950208",
 "name": "EXO Token Europe",
 "precision": 0,
 "ticker": "EXOeu",
 "version": 0
}

Reissuance

• To be able to reissue, you need only one token (satoshi) of the reissuance asset.

• If you have issued more than one reissuance asset, it means you can share that asset to others person. Then everybody who has one can reissue the asset. Though be cautious with that use-case because reissuance can be confidential, then it's nearly impossible to verify how much of the asset is in circulation.

Registration

• By default, assets are not registered on the Liquid Asset Registry.

• That gives you a chance to reissue another asset if you made a mistake before registering it.

• But once registered, it is irreversible and the tuple domain + ticker will be occupied forever.

• Details of the asset registration: https://docs.blockstream.com/liquid/developer-guide/proof-of-issuance.html

🪢 Federation

• The federation is composed of 15 functionaries

• They can propose blocks to be added to the blockchain in a round-robin fashion

• They co-sign blocks, a block needs 11 of 15 signatures to be valid

• They process peg-outs.

• When the federation will become dynamic, the total number of functionaries may vary dynamically

📃 Liquid RPC interface

Being a fork of Bitcoin, we find the same RPCs as its parent, plus some new ones like issueasset, blindrawtransaction, and more:

Source: elementsproject.org

🧰 The Liquid Ecosystem

For Users

White paper

• Liquid: https://blockstream.com/assets/downloads/pdf/liquid-whitepaper.pdf

Compatible Wallets

• Green: https://blockstream.com/green/

• Aqua: https://blockstream.com/aqua/

• SideSwap: https://sideswap.io/

• Coinos: https://coinos.io/

• Specter: https://specter.solutions/

• Marina: https://vulpem.com/marina.html

Centralized Exchanges

• Bitfinex: https://www.bitfinex.com/

• BTSE: https://www.btse.com/

• The Rock Trading: https://www.therocktrading.com/en/

• ...

DEX/Swap

• Sideshift.ai: https://sideshift.ai/

• SideSwap: https://sideswap.io/

• Bisq: https://bisq.network/

• coinos: https://coinos.io/

• TDEX: https://dev.tdex.network/

• Bitmatrix: https://beta.bitmatrix.app/

Explorers

• blockstream.info: https://blockstream.info/liquid/

• liquid.network: https://liquid.network/

For Developers

Documentation

• About Elements: https://elementsproject.org/

• About Liquid Testnet: https://liquidtestnet.com/

• About Liquid: https://docs.blockstream.com/liquid/technical_overview.html

Node

• Elements: https://github.com/ElementsProject/elements

Cached API/Backend

• Blockstream ElectRS: https://github.com/Blockstream/electrs

Explorer

• Esplora: https://github.com/Blockstream/esplora

• Blockstream Registry: https://blockstream.info/liquid/assets

Libraries

• Vulpem Go Elements: https://github.com/vulpemventures/go-elements

• Vulpem LiquidJS: https://github.com/vulpemventures/liquidjs-lib

• Vulpem LDK: https://github.com/vulpemventures/ldk

• Blockstream GDK: https://github.com/Blockstream/gdk/

• LibWally: https://github.com/ElementsProject/libwally-core

Wallet Tools

• Mnemonic Code Converter: https://iancoleman.io/bip39/

• BIP32 Generator: http://bip32.org/

Environment stack

• Nigiri: https://github.com/vulpemventures/nigiri

Sidechain available environment

Alike Bitcoin, Liquid has multiple environments at your disposal.

You can set up in your elements.conf the chain you want to use.

Liquid Regtest (chain=liquidregtest)

• I am lying to you, actually. You can input any not known chain, and it will create an Elements environment, with the parameters of your choices. So liquidregtest is not a known chain, it will start a chain named with this name. But you could name it differently like andrewschain, ethereum, or whatever. Details: https://github.com/ElementsProject/elements#modes

• Regtest stands for regression test mode. It's a mode you use to do local development.

• When initializing your node, you can specify the number of free coins you will create and that will serve as your main currency (your own test Bitcoins).

• There are no pegging, mining, or federations in place. But you can generate blocks on demand.

• To simulate a production environment, you can set up a cron task to generate a block every minute.

• Everything you do stays local in your node.

Liquid Testnet (chain=liquidtestnet)

• It was recently deployed.

• There is no pegging, so if you need coins you can use the official faucet here: https://liquidtestnet.com/faucet.

• Like in production, the block time is 1 minute.

• To configure your Elements node for it, here are the instructions: https://docs.blockstream.com/liquid/node_setup.html#connecting-to-liquid-testnet

• It has an official explorer: https://blockstream.info/liquidtestnet/

• Unlike regtest, with testnet is public hence be aware of that.

• Also, testnet has an official asset registry as well: https://blockstream.info/liquidtestnet/assets

That can be helpful to debug issuance and registration of assets, a thing you cannot do with regtest.

Liquid Mainnet (chain=liquidv1)

• The production environment of Liquid.

• As mentioned before, the block time is 1 minute, and mainnet Bitcoin can be pegged in and out of it.

🎇 Conclusion

With this knowledge, you should have enough to get started to work on Liquid.

To sum up, here are my advice, if you are willing to:

• add payment in L-BTC or another Liquid asset on your e-commerce website, look at BTCPay and WooCommerce with the Liquid+ plugin: https://github.com/ndeet/liquid-assets-for-woocommerce

• create a Liquid wallet, you can either look at the LDK made in TypeScript so good for web apps, or GDK made in C/C++ good for desktop or native apps but also has wrappers for Java, Python, and Swift,

• issue an asset (either NFT or fungible tokens too), you can look at either Blockstream AMP or build a custom solution with liquidjs or go-elements

• create an NFT trading platform, you can fork off Raretoshi

• create a SWAP/DEFI platform, look at coinos open source projects: https://github.com/coinos/.

And to go to deeper in the rabbit hole, you can start searching on these subjects:

• Multisignature wallets

• Taproot

• Partially signed transactions

• Atomic swap

Have fun!

🐦🐦🪨 Kill two birds with one stone.

Pick a subject related to something you are currently working on or something you are willing to learn.

Or 📰 Check the trending topics.

It's ok to lack inspiration. So don't hesitate to look at the trends in your field and share your experience or point of view.

How to take notes?

There are plenty of solutions:

• Notion

• EverNote

• OneNote

• Simple text files

• Notebook

• ...

You have to try and find the one that suits you the best.

But:

• Write your ideas as soon as you can, you may forget them,

• Don't elaborate on your writing yet, you want to be quick and work on the writing quality in a later step,

• Don't hesitate to use mnemonics that you know of or even create yours.

How to write the article from my notes?

Again, my suggestion is to use Hashnode

But anyway in general on most platforms nowadays you need to write in Markdown so get used to it.

Then based on your notes, write the first draft on your platform of choice.

But don't spend hours on it. Give you time constraints. Timebox the time you spend on it.

While writing:

• If you realize you lack some matter for the content, go get that matter and come back to your draft later.

• If you realize you have too much to say on the subject, don't hesitate to split your article into multiple ones. It'll be easier to read. Unless you are writing a complete guide on a subject, I would not recommend a long article.

Ok I wrote my article, I click on publish now?

No, please don't do that, yet!

🧹It's time to clean up your article! Here is the recipe:

1. https://hemingwayapp.com/ Copy-paste your contents and fix it according to the feedback. As a thumb rule at the same time, try to remove 15% of your writing. The shorter the better for your reader.

2. https://app.grammarly.com/ Copy-paste your article into a Grammarly document and fix all the left grammar issues.

3. (Optional) Get a friend or colleague to read your article and give you feedback.

Alright, remember that you don't have to get the best score in hemingwayapp, but fixing all the grammar issues is a must.

OK, I click publish now?

Wait! do you have a cover image 🖼️? No? 🤦

My advice here is:

• canva.com, it's super easy and free to create a cover image with clear titles

• or unsplash.com, it's a free website of stock photos so no titles over but good enough to illustrate an article.

So up to you, but obviously the more explicit is your picture about your article the better!

The last thing is the tags for your article.

I would suggest using a mix of trending tags and less trending ones.

You will take profit from the visibility the trending ones will offer you. And profit from the niche audience of the less trending ones.

Click on publish now!

Congrats! You published an article to the community!

Time to share the word on social networks and the internet.

Also, 🪴 don't hesitate to garden your article. Things may evolve, you may find better ways, change opinions, etc. So come back to your article and rework it.

So, 6 months before actually moving to China, I started my new job search. I sent CVs and application letters to tens of companies. I got only got very few responses and all negatives.

By the time, we were actually moving to China, I still had no job. Meaning also not a long-stay visa for me... Time was clocking.

Once in China, I continued to apply daily. I certainly felt hopeless several times and started to reconsider things.

While I was starting to consider alimentary jobs, I scheduled a couple of interviews in Shanghai.

This was somehow the last chance for me. If it was not working out, I would go for a backup plan, I was thinking. Time was clocking after all.

I got a clean haircut, shaved, and we booked a cheap hotel in a Shanghai suburb close to the train station for a week.

The first interviews went ok. But even if it was in the gaming industry, it definitely did not match my ambitions. And what I imagined.

But thankfully, the last one went well. It went great, actually. I made a good impression and the company was fascinating.

I got an offer right away that I accepted in the following hour, the interview, I believe. Ending 8 months of research. And allowing me to stay in China long-term!

But after a month and a half or about so, one morning a company meeting was summoned. The suspense didn’t last long.

The meeting was about the news: The game I was working on was canceled. And the team working on it was being laid off (including me).

But somehow I took the news very neutrally. My career in the gaming industry was just starting. And within this short lapse of time, I felt I proved to myself that I was capable of it.

I didn't want to give up on that career I was longing for and that I know I was capable of.

I resumed my job search with that spirit. But one thing was different, I had a foot in the industry. I had an apartment in Shanghai, a related experience, and a network.

Quickly I have been scheduling 7 to 8 interviews in the following week after the news. I was still very excited and formatted to do job research.

After that week full of interviews, I got a couple of offers. At the same time, I grew my network a lot, and even if I were to be laid off again, I knew I could find something else.

Finding a job is not easy! But to make it easier, here are some tips for you readers if you are currently looking for a job:

• Be in the right mindset
  To maximize your luck, you need to show self-confidence, extraversion, energy, organization, and such. If you are introverted like me, that requires some work on yourself upfront.

• If you are moving to a new location, do research on the local companies
  TBH, I lost quite some time just trying to apply to the companies I knew, or I could think of. While I could have tried to look for more local companies and understand the local ecosystem.

• Use or grow your network
  LinkedIn is great for that, or the internet in general. But also with any interview, you get. You can keep in touch with the company and/or the interviewers. A no is rarely definitive.

• Come prepared to interview
  You need to be the best of yourself, be full of energy, and ambitions. But also research info on the company and the products you may be working on.

• Be patient
  Especially if you are trying to join a new industry like the gaming industry, you may have to prove yourself. Get related experience as much as you can and build a portfolio and/or list of references.

Good luck to you in your job research!

Photo by Dylan Gillis on Unsplash

Coding and style guides

In short, the philosophy of the guides is:

• Be consistent

• Reuse the well-known types from Google

• But keep separation as needed to avoid breaking changes

Standard file formatting

• Keep the line length to 80 characters.

• Prefer the use of double quotes for strings.

File structure

Files should be named lower_snake_case.proto

All files should be ordered in the following manner:

1. License header (if applicable)

2. File overview

3. Syntax

4. Package

5. Imports (sorted)

6. File options

7. Service (1 service per file)

8. Messages (sorted in the same order of the RPCs and grouped under a comment// region $RPCNAME)

service Foo {
    rpc Bar(BarRequest) returns (BarResponse);
}

// region Bar
    message BarRequest {
        // ...
    }

    message BarResponse {
        // ...
    }

Note: // region comments are collapsible in Visual Code.

Packages

Package names should be in lowercase. Package names should have unique names based on the project name and possibly based on the path of the file containing the protocol buffer type definitions.

Message and field names

Use CamelCase (with an initial capital) for message names – for example, SongServerRequest. Use underscore_separated_names for field names (including oneof field and extension names) – for example, song_name.

message SongServerRequest {
  optional string song_name = 1;
}

Using this naming convention for field names gives you accessors like the following:

C++:
  const string& song_name() { ... }
  void set_song_name(const string& x) { ... }

Java:
  public String getSongName() { ... }
  public Builder setSongName(String v) { ... }

If your field name contains a number, the number should appear after the letter instead of after the underscore. For example, use song_name1 instead of song_name_1

Optional fields

Consider the following proto3 message which defines the field bar:

*message* Foo {  
    int32 bar = 1; 
}

With this definition, it is impossible to check whether bar has been set to 0 or if no value has been set since the default value of int32 fields is 0.

To allow you to make the difference, use:

message Foo {
  optional int32 bar = 1;
}

This exposes hasBar() and clearBar() (depending on the language) methods in the generated code.

Repeated fields

Use pluralized names for repeated fields.

  repeated string keys = 1;
  ...
  repeated MyMessage accounts = 17;

Oneof

Oneof is a wonderful example where a protobuf language feature helps to make gRPC APIs more intuitive. As an example, imagine we have a service method where users are able to change their profile picture, either from an URL or by uploading their own (small) image. Instead of doing this

// Either set image_url or image_data. Setting both will result in an error.
message ChangeProfilePictureRequest {
  string image_url = 1;
  bytes image_data = 2;
}

we can define the desired behavior directly into the message with oneof

message ChangeProfilePictureRequest {
  oneof image {
    string url = 1;
    bytes data = 2;
  }
}

Not only is that much clearer for API consumers, but it is also easier to check which field has been set in the generated code. Keep in mind that oneof also allows that none of the fields has been set, meaning there is no need to introduce a separate none field if the oneof should be optional.

Flexible Data

If you do not know in advance the nature of the data you are going to receive from your consumer, we suggest you use the well know type Struct. For example:

message StructTest {
  google.protobuf.Struct data = 1;
}

Enums

Use CamelCase (with an initial capital) for enum type names and CAPITALS_WITH_UNDERSCORES for value names:

enum FooBar {
  FOO_BAR_UNSPECIFIED = 0;
  FOO_BAR_FIRST_VALUE = 1;
  FOO_BAR_SECOND_VALUE = 2;
}

• Each enum value should end with a semicolon, not a comma. Prefer prefixing enum values instead of surrounding them in an enclosing message. The zero value enum should have the suffix UNSPECIFIED.

• Note that names of enum entries must be unique in the whole package. Defining a second completely unrelated enum with an entry existing in the first will result in an error message because of how enums in C and C++ are implemented. To avoid this, prefix the enum entries with the enum name. Some code generators (ex. for C#) will remove these prefixes automatically so that the resulting code looks "clean" again.

Services

If your .proto defines an RPC service, you should use CamelCase (with an initial capital) for both the service name and any RPC method names:

service FooService {
  rpc GetSomething(GetSomethingRequest) returns (GetSomethingResponse);
  rpc ListSomething(ListSomethingRequest) returns (ListSomethingResponse);
}

Separate request and response messages

We recommend that you create a separate message for each request and response. Name them {MethodName}Request and {MethodName}Reponse. This allows you to modify request and response messages for a single service method without introducing accidental changes to other methods. It is tempting to re-use messages and simply ignore fields that aren't needed. With time, this will result in a mess, since it isn't obvious what the API expects. Exceptions to this rule are usually made when returning a single, well-defined entity or when returning an empty message.

service BookService {
  rpc CreateBook(Book) returns (Book); // don't do this
  rpc CreateBook(Book) returns (google.protobuf.Empty); // instead do this
  rpc ListBooks(ListBooksRequest) returns (ListBooksResponse); // this is OK
  rpc GetBook(GetBookRequest) returns (Book); // this is also OK
  rpc DeleteBook(DeleteBookRequest) returns (google.protobuf.Empty); // this is also OK
}

Use the error system

Do not return a simple confirmation to an endpoint that does not need to return any other data, use google.protobuf.Empty and trigger an error if needed.

// Don't
service BookService {
  rpc DeleteBook(DeleteBookRequest) returns (DeleteBookResponse); 
}

message DeleteBookResponse {
  bool deleted = 1;
}

// Do 
service BookService {
  rpc DeleteBook(DeleteBookRequest) returns (google.protobuf.Empty); 
}

Don’t reinvent the wheel

Use and abuse of the well-known types:

https://developers.google.com/protocol-buffers/docs/reference/google.protobuf

Examples:

• The empty message is already defined as google.protobuf.Empty, so it doesn't make sense to define yet another empty message.

• Don’t try to redefine timestamp, there’s an existing type for it: https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#timestamp

• ...

Don’t have one field in a struct influence the meaning of another

Protocol buffer messages usually have multiple fields. These fields should always be independent of each other — you shouldn’t have one field influence the semantic meaning of another.

// don't do this!
message Foo {
  int64 timestamp = 1;
  bool timestampIsCreated; // true means timestamp is created time,
                           // false means that it is updated time

This causes confusion — the client now needs to have special logic to know how to interpret one field based on another. Instead, use multiple fields, or use the protobuf “oneof” feature.

// better, but still not ideal because the fields are mutually
// exclusive - only one will be set
message Foo {
  int64 createdTimestamp;
  int64 updatedTimestamp;
}// this is ideal; one will be set, and that is enforced by protobuf
message Foo {
  oneof timestamp {
    int64 created;
    int64 updated;
  }
}

Linting

We use protolint to lint the proto files. Please download and install protolint from https://github.com/yoheimuta/protolint/releases.

Git pre-commit hook

You can also enforce protolint to execute automatically before committing code using pre-commit. Install pre-commit, add a file .pre-commit-config.yaml, and add this content to it:

 repos:
  - repo: https://github.com/yoheimuta/protolint
    rev: master
    hooks:
      - id: protolint

Then run: pre-commit install in the repo.

Extra recommendations

• Use CI to automatically double-check if your proto files still compile without error/warnings.

• Avoid large messages. gRPC is not designed for that. Details: https://kreya.app/blog/grpc-best-practices/#large-messages

• Reuse channels. Creating a gRPC channel is a costly process, as it creates a new HTTP/2 connection. Details: https://kreya.app/blog/grpc-best-practices/#reuse-channels

References

• https://developers.google.com/protocol-buffers/docs/style

• https://kreya.app/blog/grpc-best-practices/

• https://medium.com/@akhaku/protobuf-definition-best-practices-87f281576f31