List of English posts on Hossein Naghdbishi

The Courage to Be Disliked Summary

hossein@naghdbishi.com (Hossein Naghdbishi) — Mon, 11 May 2026 23:19:04 +0330

The Courage to Be Disliked is a book written in a dialogue form between a young man and a philosopher. The book uses this Socratic form to teach us about Adlerian psychology.

We are All Subjective Beings

The book posists that we can never escape from our subjectivity, and that we ourselves choose how to interpret what we see and what meaning to attribute to it. For example a person who is short can see it as an advantage or a disadvantage, it's totally up to them. A diamond, too, could be seen as nothing but a small stone. Objective facts cannot be altered, but we can change our subjective interpretation as much as we like. Therefore, our attitude, how we see the world, is of utmost importance. Our present is not determined by our experiences in the past, but by the meaning we have attributed to them: “No matter what has occurred in your life up to this point, it should have no bearing at all on how you live from now on.”

The most important thing is not in what circumstances we were born, but on how we utilize the hands we're dealt. “It’s not what one is born with but what use one makes of that equipment”. Instead of focusing on the past and what could have been, we must focus on what we can do with our current equipment:

Freudian etiology is a psychology of possession, and eventually it arrives at determinism. Adlerian psychology, on the other hand, is a psychology of use, and it is you who decides it.

Etiology vs Teleology

We can approach psychology either through etiology or teleology (then there is logotherapy which focuses on the future). In Freudian psychology we tell ourselves stories of the past to study why we behave in a certain way. Etiology is studying the past to understand the causes of a behavior. In Adlerian psychology, however, it is suggested that we decide our behavior right now, and any decision on our part is because we have chosen to benefit from it. For example, the reason a NEET doesn't leave the house is not because of a past trauma or fear, but rather because they enjoy the comfort and attention they are paid by their parents, even if they're miserable in all other respects. The book stresses that there is no such thing as trauma and every one of our behaviors is used for a purpose. Studying what we hope to achieve by our current behavior is teleology, in other words: "People are not driven by past causes, but move toward goals that they themselves set". Instead of asking 'Why am I like this?' (Etiology), Adler asks 'What is my goal in acting this way?' (Teleology). This shifts the power back to the individual. Another example is being unhappy. If we're unhappy, it's because we actively choose being unhappy, and that we've judged it to be good for us. If there's something we want to change in ourselves, again, we're always able to do so, and the only reason we don't is because we are making the decision not to. By holding this view, we don't wait for others to change or the situation to change, we take the first step ourselves. The past and how we got here don't matter, and how we do from here on is our responsibilty. Here's another example from the book, about the son of a father who hit him in his childhood:

As long as I use etiology to think, It is because he hit me that I have a bad relationship with my father, it would be a matter that was impossible for me to do anything about. But if I can think, I brought out the memory of being hit because I don’t want my relationship with my father to get better, then I will be holding the card to repair relations. Because if I can just change the goal, that fixes everything.

"Lifestyle", one's worldview and outlook on life, is something the person chooses for themselves. If we don't change it, it's mostly because we've grow accustomed to it, and we fear that by going to uncharted territories we may get hurt. Anxiety is generated by changing, and disappointment by not changing, and most people usually choose the latter. In other words, most people are lacking in the courage to change and be happy.

Apparent Cause and Effect

The book offecs a poignant observation on "apparent cause and effect"—the way we contruct logical-sounding excuses to justify our stagnation. For example the book tells the story of a girl who created a fear of blushing to avoid proposing to a boy she liked and risking rejection. Many of us are guilty of the same crime. We come up with excuses every day, and force ourselves to see a as door closed, in order to escape the pain of trying and risking.

A parabole for an unwritten and procrastinating life itself:

I have a young friend who dreams of becoming a novelist, but he never seems to be able to complete his work. According to him, his job keeps him too busy, and he can never find enough time to write novels, and that’s why he can’t complete work and enter it for writing awards. But is that the real reason? No! It’s actually that he wants to leave the possibility of “I can do it if I try” open, by not committing to anything. He doesn’t want to expose his work to criticism, and he certainly doesn’t want to face the reality that he might produce an inferior piece of writing and face rejection. He wants to live inside that realm of possibilities, where he can say that he could do it if he only had the time, or that he could write if he just had the proper environment, and that he really does have the talent for it. In another five or ten years, he will probably start using other excuses like “I’m not young anymore” or “I’ve got a family to think about now.” YOUTH: I can relate all too well to how he must feel. PHILOSOPHER: He should just enter his writing for an award, and if he gets rejected, so be it. If he did, he might grow, or discover that he should pursue something different. Either way, he would be able to move on. That is what changing your current lifestyle is about. He won’t get anywhere by not submitting anything.

Life Is Not a Competition

Human beings are equal but not the same; this means that a math genius is no more valuable than a child who can't do simple arithmetic, or even a bedridden person with no activity. If we have a view that leads us to believe there is a competition going on, it will make us say words like "I lost to that person" or "I beat that person". In turn, we will see other people as enemies. We can't celebrate their happiness because their victory is our defeat, and this deprives us of a sense of community.

But every person has a sense that they need to grow even more, and a small amount of feeling lacking in a good quality is healthy for growth. Since we're equals, this healthy sense comes not from comparing ourselves with other people, but with comparing us with our ideal selves. Life is not a competition and we should move forward without competing with others. However, a problem is created when a healthy sense of inferiority becomes inferiority complex. In this case, we will use our sense of inferiority as an excuse, we will say things like "A happened so B can't", or "If it only weren't for A, I could have achieved B". These are all excuses/life-lies.

One may even not aim for success—perhaps to protect their leisure time or out of a deep-seated fear of failure. So while one might claim "the reality is that having a good education makes it easier to be successful in society." but "The real issue is how one confronts that reality. If what you are thinking is, I’m not well educated, so I can’t succeed, then instead of I can’t succeed, you should think, I don’t want to succeed." If we don't lack the courage, we will be diligent and find a solution to our problem. However, if we lack the courage, we will either boast about our misfortunes (saying things like 'you don't know what I've been through', like a baby who rules with his weakness), or get caught up in a superiority complex, boasting about the memories past.

Life-tasks

According to Adler, all problems are interpersonal problems. But not only our unhappiness is caused by interpersonal relationship, so is our happiness.

In Adlerian psychology, there are 2 objectives for human behavior: to be self-reliant, and to live in harmony with the society, which are supported by the two objectives of psychology: "I have the ability" and "People are my comrades". These two objectives can be achieved by facing "life tasks": tasks of work, tasks of love and tasks of friendship, all of which involve interpersonal relationships.

Courage and Worth

If one is not following through with their life-tasks, it is not because they're not able to, but because they have lost the courage to face their tasks. They should first realize that it is them who holds all the cards and decides what to do with them (have a teleological attitude and change the goal), and other people who want to help should use 'encouragement'. They should not judge the person or let assistance become intervention, but show by gratitude that they believe in them, that they value their relationship with them, and respect them. In Adler's view, "It is only when a person is able to feel that he has worth that he can possess courage", and courage is a prerequisite to change. But how can one feel like they have worth? It is when they feel "I am beneficial and making a contribution to the community" or that "I am of use to someone". However this feeling of worthiness doesn't have to be something at the level of acts, but at the level of being. We love our grandparents just by them being present, not but the things that they do for us. The same can be true for anyone, even NEETs. “People can be of use to someone else simply by being alive, and have a true sense of their worth just by being alive.”

How should we increase courage then? Acceptance, Confidence, Focusing on the Strength.

We should first accept who we are, just the way we are, and feel at ease with ourselves. We should also believe in ourselves and have the courage to take the step forward regardless of the outcome. This focus on the process of growth and journey, rather than the outcome is called encouragement.
We should form a belief within, that we're capable and we're 'enough' as long as we have the courage try. It is the antidote to inferiority complex and moves us from praise based on the outcome "I like it when I/you do well/achieve." to "I believe in my/your ability to handle this.", "I am worthy because I had the courage, regardless of the outcome".
By noticing on every small step that we get right, our confidence in ourselves increases and we may grow even more.

"The state of coming up with all manner of pretexts [excuses] in order to avoid the life tasks" is a “life-lie”. And life-lies aren't about being bad or evil, but about lacking courage. When telling a life-lie:

One shifts one’s responsibility for the situation one is currently in to someone else. One is running away from one’s life tasks by saying that everything is the fault of other people, or the fault of one’s environment. It’s exactly the same as with the story I mentioned earlier about the female student with the fear of blushing. One lies to oneself, and one lies to the people around one, too. When you really think about it, it’s a pretty severe term.

Happiness

Happiness deeply relates to the matter of self-acceptance. We are the unhappiest of all when we dislike ourself, but we can begin to like ourselves by using the feeling of community and being of use to other people, and by self-acceptance. Our effect of contribution need not be visible either, its just a feeling that we decide to have:

Does one accept oneself on the level of acts, or on the level of being? This is truly a question that relates to the courage to be happy

and

You are not the one who decides if your contributions are of use. That is the task of other people, and is not an issue in which you can intervene. In principle, there is not even any way you can know whether you have really made a contribution. That is to say, when we are engaging in this contribution to others, the contribution does not have to be a visible one—all we need is the subjective sense that “I am of use to someone,” or in other words, a feeling of contribution. … All human beings can be happy. But it must be understood that this does not mean all human beings are happy. Whether it is on the level of acts or on the level of being, one needs to feel that one is of use to someone. That is to say, one needs a feeling of contribution. … In a word, happiness is the feeling of contribution. That is the definition of happiness.

Note that this sense of being of use to the community is intrinsic, and is deeply different from being recognized and valued by others.

If one really has a feeling of contribution, one will no longer have any need for recognition from others. Because one will already have the real awareness that “I am of use to someone,” without needing to go out of one’s way to be acknowledged by others. In other words, a person who is obsessed with the desire for recognition does not have any community feeling yet, and has not managed to engage in self-acceptance, confidence in others, or contribution to others.

Separation of Tasks, and Avoiding of Judgement

Adlerian psychology denies the need for recognition from others, and states that one should neither rebuke, nor praise. If we seek recognition from others, we are living other people's lives, and letting them have the interpersonal relationship cards. "If you don't live your life, who is going to live it for you?" One might imagine that we at least need recognition from our parents, or God to live a good life, but this is false.

We need to continually separate our tasks from those of others. A simple way to see whose task it is, is to ask who's going to ultimately get the result from the choice being made. Even things that seem mundane, such as urging a child to study is not recommended, it is not the parent's tasks to study, just to lend a hand whenever they're asked. The child has no obligation to fulfill their parents' expectations either. When doing the right thing, how people construe our actions and feel as a result is not our task either, it is their task to choose their attitude. Also, we must be astute enough to know when to resign, if it is not our task, or if we're unable to change something, we must know when to resign. To be able to do so shows that we have a firm grasp on the truth of things.

Freedom is being disliked by other people. We must not be afraid of being disliked. Behaving in a decent manner is our task, but whether other people like us or not is not. It is not our task to fulfill other people's expectations. Freedom is resisting one's instincts and impulses, a stone is powerless once it has begun to roll downhill, but we are not stones.

Community

Adler put great emphasis on the feeling of community, on the feeling of "having one's refuge" and "it's okay to be here", that other people (and even animals and objects) are our comrades. It is when we realize that "I" is not the center of the world and when we switch from self-interest to concern for others that are we are the most happy. It is through active commitment to the community of one's accord that this happens, not by simply being there. Instead of "What will this person give me?", we will ask "What can I give to this person".

The relationships we build in the community should be horizontal, meaning that in its basis we must treat and be treated as equals. It is for this reason that we don't praise other people, praising (as well as rebuke) is a form of manipulation. We must not praise or rebuke, but encourage and express confidence in one another and gratitude. We could even treat our friends in a vertical manner:

Even if you are not treating them in a boss-or-subordinate kind of way, it is as if you are saying, “A is above me, and B is below me,” for example, or “I’ll follow A’s advice, but ignore what B says,” or “I don’t mind breaking my promise to C.”

But this undermines the very purpose of relationships, as "the final goal of interpersonal relationships is a feeling of community".

For community feeling, "self-acceptance", "confidence in others", and "contribution to others" is required.

Self-acceptance is not "I can" or "I am strong", it is not self-affirmation, but acknowledging our not being perfect and trying anyway.
Confidence is different from trust, in the sense that confidence is a form of belief that requires no surety and is unconditional. The opposite of confidence is doubt, and one should not doubt the ability of their friends and loved ones.
Contribution to others happens not as a self-sacrifice which is something Adler denies, but as a way to get a sense of community, and feeling worthy, dedicated to a cause greater than ourselves.

Concept	Definition	The "Shift"
—	—	—
Self-Acceptance	Acknowledging imperfection without self-affirmation lies.	From "I must be special" to "I am enough as I am."
Confidence	Unconditional belief in others without requiring surety.	From "I trust you if…" to "I believe in you regardless."
Contribution	The subjective sense of being of use to the community.	From "What do I get?" to "What can I give?"
Teleology	The study of the purpose behind current behaviors.	From "I am stuck because of my past" to "I choose this for a goal."

Life is a Series of Dots

There is much merit in accepting to be normal, and normal doesn't mean incapable. Both children that try to get excellent grades and those who try to attract attention by problem behavior are in search of being a "special being". However, pursuit of superiority is an unhealthy attitude. Avoiding perfectionism and accepting to be a normal being is an important part of self-acceptance. People who pursue superiority are tentative in their being, 'en route' to some destination. They can't rest until they arrive, but life is not a competition but a journey to be enjoyed. Life is not a line (kinetic) but a series of dots (energeial). If you finished a marathon using a helicopter that'd be pretty meaningless, so life is not a marathon, but a dance:

Life is a series of moments, which one lives as if one were dancing, right now, around and around each passing instant. And when one happens to survey one’s surroundings, one realizes, I guess I’ve made it this far. Among those who have danced the dance of the violin, there are people who stay the course and become professional musicians. Among those who have danced the dance of the bar examination, there are people who become lawyers. There are people who have danced the dance of writing and become authors. Of course, it also happens that people end up in entirely different places. But none of these lives came to an end “en route.” It is enough if one finds fulfillment in the here and now one is dancing.

In a dance one is engaged in each moment, and it is enough that we do what we can do now, earnestly and conscientiously, but in doing so we must not get too serious and keep our lives simple.

For example, one wants to get into a university but makes no attempt to study. This an attitude of not living earnestly here and now. Of course, maybe the entrance examination is still far off. Maybe one is not sure what needs to be studied or how thoroughly, and one finds it troublesome. However, it is enough to do it little by little—every day one can work out some mathematical formulas, one can memorize some words. In short, one can dance the dance. By doing so, one is sure to have a sense of “this is what I did today”; this is what today, this single day, was for. Clearly, today is not for an entrance examination in the distant future. … And the same may be said with regard to your own life. You set objectives for the distant future, and think of now as your preparatory period. You think, I really want to do this, and I’ll do it when the time comes. This is a way of living that postpones life. As long as we postpone life, we can never go anywhere and will pass our days only one after the next in dull monotony, because we think of here and now as just a preparatory period, as a time for patience. But a “here and now” in which one is studying for an entrance examination in the distant future, for example, is the real thing. … The greatest life-lie of all is to not live here and now.

Life's meaning is what we attribute to it. We have freedom in the meaning we assign to it and the choices we make, and our guiding star in these is contributing to the community:

Regardless of the circumstances, we must take some form of action. We must stand up to Kant’s “inclination.” Now, suppose one experiences a major natural disaster, and one’s response is to look back at the past in an etiological manner and say, “What could have caused such a thing to happen?” How meaningful would that be? An experience of hardship should be an opportunity to look ahead and think, What can I do from now on?

Misc

Adler believed in holism, meaning that we can't separate ourselves from our emotion, or somehow make us think of us as being cosisted of different systems.

PHILOSOPHER: Suppose, for instance, that there is a certain Mr. A whom you don’t like because he has some flaws that are hard to forgive. YOUTH: Ha-ha, if we’re looking for people I don’t like, there’s no shortage of candidates. PHILOSOPHER: But it isn’t that you dislike Mr. A because you can’t forgive his flaws. You had the goal of taking a dislike to Mr. A beforehand and then started looking for the flaws to satisfy that goal. YOUTH: That’s ridiculous! Why would I do that? PHILOSOPHER: So that you could avoid an interpersonal relationship with Mr. A.

Summary of Man's Search for Meaning

hossein@naghdbishi.com (Hossein Naghdbishi) — Sun, 10 May 2026 14:54:47 +0330

"Man's Search for Meaning" is about the experiences and philosophy of Viktor Frankl, a concentration camp survivor. As a psychiatrist who endured many atrocities, he uses his observations in the camp to claim that life remains meaningful and worthwhile even under the most extreme circumstances. As we have freedom, not in conditions of life, but in how we respond to life, we get to choose to become a saint or a swine, not as the effect of the environment, but because of our freedom to choose. One's attitude is the ultimate liberty that cannot be taken away from us, and what makes life meaningful under the most extreme circumstances.

His answer to the famous question of "life's meaning" is similar to that of Tolstoy's famous 'Three Questions' story. Just like a chess game that has no best move in general, but a best move at every moment, so does life. The best thing we can do, and the meaning of our life is determined by the moment we are facing now and how we decide to respond to life's circumstances. Therefore, it is not that we ask what's the meaning of life, but that we get to know what life asks of us, and whether we wish to endure hardships and live it with much dignity.

He claims that human life usually derives its meaning from one of these:

Being creative and actually creating something, such as authoring a book
Interpersonal relationships, like the joy of seeing one's child, or loving another person
While the most important thing is to be creative and change the root cause of our suffering, if need be, just facing an unchangeable hardship with great dignity and courage, learning to change ourselves and grow spiritually as a result is a worthy meaning.

As a result, life remains valuable in all circumstances, and we can "say yes to life, in spite of everything". One reason that every life is valuable and meaningful is that we don't know everything. He points out that since we do not know everything about this world, there might be a supermeaning to our life, a meaning beyond our comprehension. Therefore, we must try our best at all times.

He also warns against trying to live in the past. While one can do so in moderation, doing so excessively may cause us to lose sight of the opportunity of growth that is in front of us. Every difficulty is a chance to test our inner strength and a chance to grow and reach inner triumph. It is of utmost importance that we believe (a belief, a kind of faith as William James would put it) in the future. "The prisoner who had lost faith in the future—his future—was doomed. With his loss of belief in the future, he also lost his spiritual hold; he let himself decline and became subject to mental and physical decay."

Frankl believes that human's main concern is not to seek pleasure or avoid pain, but to see a meaning in one's life. He reports that it wasn't the bulky men who survived at the end, but those who had a goal beyond themselves such as writing a book only they could write, or seeing their children again.

That is why people sometimes even choose to suffer. And it is how one can restore a man’s inner strength in the camp, by showing him some future goal. Nietzsche’s words, “He who has a why to live for can bear with almost any how,” could be the guiding motto for all psychotherapeutic and psychohygienic efforts regarding prisoners. Whenever there was an opportunity for it, one had to give them a why—an aim—for their lives, in order to strengthen them to bear the terrible how of their existence. Woe to him who saw no more sense in his life, no aim, no purpose, and therefore no point in carrying on. He was soon lost. The typical reply with which such a man rejected all encouraging arguments was, “I have nothing to expect from life any more.” What sort of answer can one give to that?

What was really needed was a fundamental change in our attitude toward life. We had to learn ourselves and, furthermore, we had to teach the despairing men, that it did not really matter what we expected from life, but rather what life expected from us. We needed to stop asking about the meaning of life, and instead to think of ourselves as those who were being questioned by life—daily and hourly. Our answer must consist, not in talk and meditation, but in right action and in right conduct. Life ultimately means taking the responsibility to find the right answer to its problems and to fulfill the tasks which it constantly sets for each individual."

Frankl's philosophy extends beyond the camps. Jerry Long is another logotherapist. He, a quadriplegic who became a university professor, says:

Once, after speaking to a large audience, I was asked if I ever felt sad because I could no longer walk. I replied, "Professor Frankl can hardly see, I cannot walk at all, and many of you can hardly cope with life. What is crucial to remember is this - We don't need just our eyes, just our legs, or just our minds. All we need are the wings of our souls and together we can fly.

Reading this book I think I found my answer to a question I have had for a long time. While people are equal and cannot be compared due to different circumstances, ceteris paribus, what makes another person better than the other? "It is a question of the attitude one takes toward life’s challenges and opportunities, both large and small." People should be an active designer of their life story by making good decisions in every single moment of their life, determining how they want their life to look like.

Poor Man's VPN: How to Use Reverse SSH for Quick NAT Traversal

hossein@naghdbishi.com (Hossein Naghdbishi) — Sat, 03 Jan 2026 23:53:49 +0330

Suppose you want to connect from PC A to PC B, and neither have a pubilc IP. How can you do that? One way is to use iroh-ssh, it's neat but currently they don't support custom relays so it's a deadend in more restricted networks. But if you own a VPS, you can actually can connect these two.

Assuming you have installed autossh on B, create a systemd service on it as well /etc/systemd/system/autossh-ssh.service:

[Unit]
Description=AutoSSH Service
After=network.target

[Service]
Type=simple
User=user
Environment=AUTOSSH_GATETIME=0
ExecStart=/usr/bin/autossh -M 0 -N -o "ServerAliveInterval 30" -o "ServerAliveCountMax 10" -o "ExitOnForwardFailure yes" -o "AddressFamily inet" -o "TCPKeepAlive no" -R localhost:REMOTE_SSH_PORT_ON_VPS:localhost:SSH_PORT_OF_B -i YOUR_KEY_ADDRESS USER@VPS -p VPS_SSH_PORT
Restart=always
RestartSec=5
KillMode=process # Ensure child processes are not killed

[Install]
WantedBy=multi-user.target

Then enable it using sudo systemctl enable autossh-ssh. Now it will always keep a connection to your VPS and expose its SSH port on your VPS's localhost:REMOTE_SSH_PORT_ON_VPS (localhost can be changed to your VPS's static IP if that's what you need). Now you can connect to B on your VPS.

If you need B's SSH port on A, you have to port forward: ssh user@VPS_IP -p VP_SSH_PORT -L localhost:REMOTE_SSH_PORT_ON_A:localhost:REMOTE_SSH_PORT_ON_VPS, which means you can connect to B from A: ssh user@localhost -P REMOTE_SSH_PORT_ON_A. Q.E.D!

Side note: If for whatever reason you can't connect to B, then go to your VPS, kill the SSH that is responsible for the REMOTE_SSH_PORT_ON_VPS. After some time B will create a fresh connection which has a better likelihood of good connection.

Side note: If you own a VPS maybe you're not so poor monetarily but rather temporarily, since you don't have time to deal with Wireguard and so on.

Update: Just use yggdrasil instead.

PWN Cheatsheet

hossein@naghdbishi.com (Hossein Naghdbishi) — Sun, 16 Nov 2025 23:30:51 +0330

x86_64 Assembly

%rax is a reference to rax register.
$0x4 is a constant.
0(%esp) or (%esp) is the value loaded from the memory address that is stored in %esp.
12(%esp) dereferences memory 12 bytes above the address contained in ESP
mov A,B, B is changed to become A. A's value is -> put into B.
- This is AT&T x86 syntax (what GDB uses). In this syntax the destination register comes last. In RISC-V assembly the opposite is true.
push A adds A as the last element of the stack, decreases the value of rsp/esp by one word (since the stack grows from high to low).
pop rax/eax removes the last element of the stack, copies into rax/eax increases the value of rsp/esp by one word (since the stack grows from high to low).
jmp is equivalent to mov rip, target_address
call is equivalent to push rip(old return address) and jmp dst_func.
ret is equivalent to pop rip(old return address) which is jmp src_func.
Because stack grows from high addresses to low addresses:
- sub $8,%rsp increases stack size.
- add $8,%rsp decreases stack size.

Stack

Backgroud

Each byte is 8 bits.
Each word is 4 bytes in 32-bit systems and 8 bytes in 64-bit systems.
Each register can store one word.

Registers

Pointing to the code section

rip/eip is the instruction pointer, and it stores the address of the machine instruction currently being executed (code section). In RISC-V, this register is called the PC (program counter).

Pointing to the stack section

rbp/ebp is the base pointer, and it stores the address of the base of the current stack frame. In RISC-V systems, this register is called the FP (frame pointer).
rsp/esp is the stack pointer, and it stores the address of the last element of the current stack frame. In RISC-V, this register is called the SP (stack pointer).

General Purpose Registers

16 general purpose registers in 64-bit systems: RAX, RBX, RCX, RDX, RSI, RDI and R8 to R15.
6 general puprose registers in 32-bit systems: EAX, EBX, ECX, EDX, ESI, EDI.

Argument	Register (64-bit)
Arg 1	%rdi
Arg 2	%rsi
Arg 3	%rdx
Arg 4	%rcx
Arg 5	%r8
Arg 6	%r9

Little Endian or Big Endian

Address numbers point to bytes.
Using little endian 0x44332211 will be stored like 0x11 0x22 0x33 0x44 in memory, meaning that the most signifcant byte has the highest address number (the memory starts from 0x0 to 0x3, and 0x44 is stored at 0x3).

Function Call in x86

See the photos in UC Berkeley's CS161 Textbook

Function args are pushed into the stack. (or onto the general registers such as rdi, rsi, rdx, rcx if SysV x86-64)
Return address (old rip) is pushed into the stack.
Function jump happens (rip = new rip)
The new function pushes old rbp onto the stack.
Previous frame's rbp becomes the current rsp (old function's last element is the new functions bottom)
rsp is grown to fit the new function.
The new function does whatever it does
At the end of the new function's run, we are at its rbp, which is the old one's rsp. Previous frame's rsp is the present frame's rbp.
Old rbp is poped back.
Old rip is poped back.
Decrease the size of the stack by the size of args.

Example C code

void foo(int a, int b) {
 int bar[4];
}

int main(void) {
 foo(1, 2);
 return 0;
}

Which gives the following assembly:

0000000000001129 <foo>:
 1129:	55 	push %rbp // Step 4. RBP is saved on the stack right below RIP (saved in the previous step).
 112a:	48 89 e5 	mov %rsp,%rbp // Step 5. The new stack base is the previous stack pointer.
 112d:	89 7d ec 	mov %edi,-0x14(%rbp) // Foo saves first arg into its own stack to free up %edi 
 1130:	89 75 e8 	mov %esi,-0x18(%rbp) // Foo saves second arg into its own stack to free up %esi
 1133:	90 	nop // Alignment, could be Step 6. =sub $N, %rsp= & Step. 7 if our function involved anything.
 // Since Step. 6 didn't take place, rsp didn't change.
 // therefore =mov %rsp, %rbp= (Step 8) is not run either.
 // We could change this behavior using gcc flag -mno-red-zone
 1134:	5d 	pop %rbp // Step 9. Old RBP is restored
 1135:	c3 	ret // == pop %rip which is Step 10. Old RIP is restored
 // Step 11. doesn't happen since in the x86-64 ABI, since the caller
 // passed arguments in registers, there is nothing on the stack for
 // the caller to clean up

0000000000001136 <main>:
 1136:	55 	push %rbp // This is step 4 since main is not the starting function and is being called from _start
 1137:	48 89 e5 	mov %rsp,%rbp // this is also step 5 but we don't analyze main.
 113a:	be 02 00 00 00 	mov $0x2,%esi // Step 1. Saving args (from right to left): 2 
 113f:	bf 01 00 00 00 	mov $0x1,%edi // Step 1. Saving args (from right to left): 1 
 1144:	e8 e0 ff ff ff 	call 1129 <foo> // Step 2. RIP is pushed on the stack. Step 3. RIP is changed to the func address of foo (00001129).
 1149:	b8 00 00 00 00 	mov $0x0,%eax
 114e:	5d 	pop %rbp
 114f:	c3 	ret

Binary Background Check

Purpose	Command
Check security properties (NX bit, dynamic vs static)	`rabin2 -I a.out`
List functions imported from shared libraries	`rabin2 -i a.out`
Find functions likely written by the programmer	`rabin2 -qs a.out` piped to `grep -ve imp -e ' 0 '`
Find strings	`strings a.out` or (better) `rabin2 -z split`

Return Oriented Programming

Finding ROPs

With ROPGadget:

ROPgadget --binary libc.so.6 --only "add|jmp" > output # in case you're looking for add followed by jump for example, otherwise remove
cat output | grep 'add rdi, 0x10 ; jmp rc'

With Ropper:

ropper --file ./libc.so.6 --search "add rdi, 0x10; jmp rcx"

Misc

PLT (Procedure Linkage Table): a small trampoline in the binary used for calls to external (dynamically linked) functions. Calls in the code go to func@plt; the PLT entry jumps to the real function address found in the GOT (or invokes the dynamic resolver on first call).
GOT (Global Offset Table): a writable table of addresses in the binary. Each GOT slot holds the runtime address of a library function (or other dynamic symbol). The dynamic linker/loader fills GOT entries the first time a PLT entry is used (or at load time, depending on RELRO).
They let the loader resolve and redirect calls to shared-library functions without embedding fixed library addresses in the code (works with ASLR and dynamic linking).

Memory Alignment

Why it happens: to give data to the CPU/CPU cache in one read instead of two

Sources

Disclaimer: Some of the sentences here are a direct copy of the links below, so I don't own their copyright. Follow the original sources.

How to Share a Secret: Summary of Shamir's Paper

hossein@naghdbishi.com (Hossein Naghdbishi) — Mon, 11 Aug 2025 13:15:47 +0330

In his 1979 paper, Adi Shamir explains an ingenious way to share a secret between n people, such that only if k of them cooperate will the secret be revealed. And that even if k-1 people cooperated, nothing would be revealed.

How it works is simple. For a polynomial of degree 1 (i.e, $f(x)=a_{1}x+a_{0}$), how many (x,y) points do you need to find $a_{1}$ and $a_{0}$? Two. If you had only one point, you could find a relationship between $a_{0}$ and $a_{1}$ but that would be all. For a polynomial of degree 2 (i.e, $f(x)=a_{2}x^2+a_{1}x+a_{0}$), how many (x,y) points do you need to find $a_{2}, a_{1}$ and $a_{0}$? Three. If you had only two points, there would still be an infinite pairs of $a_{2}$, $a_{1}$ and $a_{0}$.

Knowing what we know about polynomials, suppose n people need to be able to be part of our trusted group, such that if k of them cooperated, they could work out the secret.

We set $a_{0}$ as our secret. We generate a polynomial of degree k-1 so there are k coefficients and at least k points or cooperating members are needed. Except for $a_{0}$ which is our secret, we generate the coefficients ($a_{1}$ to $a_{n}$) randomly. Then we index our n members give them each the f(x) of their index, so member one gets f(1), member two gets f(2) and so on up to member n who gets f(n). Now if any k members cooperate, they'll have the numbers to find out all the coefficients, and work out $a_{0}$. Easy as that. We will also use modulo arithmetic for our polynomial equations so every number is equally likely in it.

Tail Recursion

hossein@naghdbishi.com (Hossein Naghdbishi) — Sun, 10 Aug 2025 11:18:51 +0330

As nice as recursion is, sometimes our stack may grow too large, causing our program to crash due to running out of stack space. However, some languages support tail call optimization. That is, if you write your function in a way that leaves no need to use the previous stack, the compiler will use the same stack for its job and you'll never hit the stack overflow problem.

For example, here's a Fibonacci implementation in C.

// badfib.C
#include <stdio.h>

// Non-tail recursive function for Fibonacci
int fibonacci(int n) {
 if (n == 0) return 0;
 if (n == 1) return 1;
 return fibonacci(n - 1) + fibonacci(n - 2);
}

int main(void) {
 int n;
 printf("Enter a number: ");
 scanf("%d", &n);
 printf("Fibonacci of %d is %d\n", n, fibonacci(n));
 return 0;
}

Using this code, calculating the 5th term (1,1,2,3,5) can be done like the picture above. You can see the stack frames grow too long. Each call of the function waits for the return of at least two other function calls, and neither of the first two branches can be calculated until we reach fibonacci(0) and fibonacci(1). Since we need to keep track of what two numbers are being added together, we also can't reduce the amount of data we keep.

❯ gcc -O0 badfib.c -o badfib
❯ ./badfib
Enter a number: 500000
[1] 43221 segmentation fault (core dumped) ./badfib
❯ gcc -O1 badfib.c -o badfib_optimized
❯ ./badfib_optimized
Enter a number: 500000
[1] 43283 segmentation fault (core dumped) ./badfib_optimized
❯ gcc -O3 badfib.c -o badfib_super_optimized
❯ ./badfib_super_optimized
Enter a number: 500000
# takes too long :)

As you can see, no matter the level of optimization, the code doesn't finish in the way we want it to.

Now suppose we refactor our code like this:

#include <stdio.h>

// Tail recursive function for Fibonacci
int fibonacci_tail(int n, int a, int b) {
 if (n == 0) return a;
 if (n == 1) return b;
 return fibonacci_tail(n - 1, b, a + b);
}

int fibonacci(int n) {
 return fibonacci_tail(n, 0, 1);
}

int main(void) {
 int n;
 printf("Enter a number: ");
 scanf("%d", &n);
 printf("Fibonacci's %d term is %d\n", n, fibonacci(n));
 return 0;
}

Here's how the functions are called:

fib(5) : fib_tail(5, 0, 1)
fib_tail(5,0,1) : fib_tail(4,1,1)
fib_tail(4,1,1) : fib_tail(3,1,2)
fib_tail(3,1,2) : fib_tail(2,2,3)
fib_tail(2,2,3) : fib_tail(1,3,5)
fib_tail(1,3,5) : 5

Or in a nice little picture:

You may have noticed that this time is no different. It is less messy, sure, but each function still needs to wait for the result of another function so that it can finally return the value and remove its stack. The nice thing about this function, though, is that it can be optimized. At each turn we're accumulating the values we need inside two variables, and even if we only keep track of the last function call, we will still have the correct result.

Key idea: You can refractor your recursive functions, such that the recursive function call is being done at the end of the function, and the ultimate result that you will return isn't dependent on anything but the data in the very last function call. Then some languages like C will discard your stack at each new call and will just keep the last function call at each step. This will result in less memory usage and prevention of stack overflow. This is the essence of tail recursion optimization.

Let's see if the optimization makes a difference:

❯ ./fib_tail_unoptimized
Enter a number: 500000
[1] 42515 segmentation fault (core dumped) ./fib_tail_unoptimized
❯ gcc -O1 fib_tail.c -o fib_tail_optimized
❯ ./fib_tail_optimized
Enter a number: 500000
Fibonacci's 500000 term is -1975568635

It did! The answer is incorrect because int can't such a large number, but we didn't run into a stack overflow segfault either!

Not all programming languages support tail recursion optimization though. And you need to know that discarding the stack will make it harder to debug your code because the stack won't be in its complete form.

The moral of the story is that whenever you feel like you're at risk of stack overflow, go ahead and rewrite your code using an accumulator so that it can be tail optimized, or just use a loop. In the case of relying on an accumulator the compiler should support TCO optimizaiton. If it doesn't no worries. You could use GOTO (it doesn't call new functions then, and it'll reuse the same variables so it's nice) to use the same stack frame, or write a loop.

For example, here's the Fibonacci function written using a loop, nice and easy:

#include<stdio.h>

long int fib(int term){
 if(term == 1) {
 return 0;
 }
 if(term == 2 || term == 3){
 return 1;
 }

 long int a=1, b=1, c=0;
 for(int i=0;i<term-2;i++){
 c = a+b;
 a = b;
 b = c;
 printf("%d: %ld\n", i+3, c);
 }

 return c;
}

int main(void){
 fib(11);
 return 0;
}

How to share Mullvad VPN from Android on all your network?

hossein@naghdbishi.com (Hossein Naghdbishi) — Sat, 02 Aug 2025 20:53:23 +0330

Suppose you want to share your Mullvad VPN over the network, you’re connected to it on your Android phone but not on any other device. How cool would it be if you could share it with other devices? Well you can do that.

Once you connect to Mullvad VPN on your device, you’ll have access to a socks5 proxy on socks5://10.64.0.1:1080, however this IP is only accessible from your Android phone. To share it with your other devices, first install Termux, then download the correct gost binary according to your phone’s CPU architecture. Then you can instruct gost to forward all the packets it gets on port 8090 for example, to the socks5 provided by Mullvad. Done!

wget https://github.com/go-gost/gost/releases/download/v3.1.0/gost_3.1.0_linux_arm64.tar.gz # change the version and architecture accordingly
tar xfv *.tar.gz
./gost -L :8090 -F socks5://10.64.0.1:1080 # If you're in a hostile environment, use -L socks5://user:password@:8090 instead to have a socks5 proxy with authentication.

Now if inside your Mullvad app settings, “Local network sharing” is turned on, then you can easily connect to your phone’s IP from other devices and use the socks5/http/https proxy provided on its port 8090. You might think that since all servers in Mullvad offer socks5 proxy, you can access them all, but sadly this is not possbile because folks at Mullvad have decided that as soon as you turn on local network sharing, your connection to other servers should be lost.

You can use this socks5 proxy using FoxyProxy on Firefox on both Android (yes! you can install extensions on Firefox Android) and GNU\Linux/Windows/MacOS.

You Can Resolve Domains via curl Using DoH

hossein@naghdbishi.com (Hossein Naghdbishi) — Tue, 29 Jul 2025 18:37:04 +0330

Did you know you can use curl to get DNS information? Here's how:

$ curl -X GET "https://cloudflare-dns.com/dns-query?name=example.com&type=A" -H "Accept: application/dns-json"
{"Status":0,"TC":false,"RD":true,"RA":true,"AD":true,"CD":false,"Question":[{"name":"example.com","type":1}],"Answer":[{"name":"example.com","type":1,"TTL":276,"data":"23.192.228.84"},{"name":"example.com","type":1,"TTL":276,"data":"23.215.0.136"},{"name":"example.com","type":1,"TTL":276,"data":"23.192.228.80"},{"name":"example.com","type":1,"TTL":276,"data":"23.215.0.138"},{"name":"example.com","type":1,"TTL":276,"data":"96.7.128.175"},{"name":"example.com","type":1,"TTL":276,"data":"96.7.128.198"}]}%

It works on Cloudflare's ODOH server too!

$ curl -X GET "https://odoh.cloudflare-dns.com/dns-query?name=example.com&type=A" -H "Accept: application/dns-json"
{"Status":0,"TC":false,"RD":true,"RA":true,"AD":false,"CD":false,"Question":[{"name":"example.com","type":1}],"Answer":[{"name":"example.com","type":1,"TTL":35,"data":"23.192.228.84"},{"name":"example.com","type":1,"TTL":35,"data":"23.215.0.138"},{"name":"example.com","type":1,"TTL":35,"data":"23.215.0.136"},{"name":"example.com","type":1,"TTL":35,"data":"96.7.128.198"},{"name":"example.com","type":1,"TTL":35,"data":"96.7.128.175"},{"name":"example.com","type":1,"TTL":35,"data":"23.192.228.80"}]}%

If you can't bootstrap a DoH server, you can always use https://9.9.9.9/dns-query instead (though not in this format) or https://1.1.1.1/dns-query. If you already know the IP of your target, you can use curl's `–resolve` option too. curl has a `–doh-url` as well which can be used if you want curl to use DoH itself.

Note that although this method works for Cloudlare DoH servers, it is not part of any RFC so you can't really rely on them and should refer to the original RFC instead if you want to send your request to other servers.

So You Want to Learn Quicksort: Step-by-Step Guide to Basic, Lomuto & Hoare Partitioning.

hossein@naghdbishi.com (Hossein Naghdbishi) — Tue, 29 Jul 2025 11:54:15 +0330

I don’t have a Bachelor’s degree in computer science so I haven’t had any formal algorithm or data structure training. However, I am trying to remedy that by reading books and solving algorithmic questions on online platforms. One question in Hackerrank needed a sort implementation, which I couldn’t do without the help of AI, so I decided to learn about sort algorithms. I searched and found that quicksort has widespread usage, so I decided to learn it. However it was just too hard for me to grasp what was going on, so like a good programmer I decided to divide the problem into smaller parts and solve those :P.

The quicksort algorithm asks: what if we had an algorithm that takes a number (called the pivot) and divides our array into two parts, the ones smaller than the pivot and the ones larger than it? If an algorithm does this, we now have two arrays of numbers that we know don’t need to be compared. We could do the very same to those two arrays, then we keep doing this with the subarrays that are getting smaller and smaller in size, et voila! The resulting array is sorted. This is the essence of the quicksort algorithm.

The algorithm that partitions our arrays into subarrays that are all bigger or smaller than a certain number is called a partitioning algorithm. Most educational materials on quicksort conflate Lomuto’s and Hoare’s partitioning algorithms with the quicksort algorithm itself, so we could easily lose sight of the big picture. I have written a C quicksort program that is inefficient, yet easy to understand.

Let’s learn about the silliest partitioning algorithm possible; then we can easily learn quicksort, even when it uses the right partitioning algorithms.

Basic Partitioning

In the following code, we’ll partition an array of numbers into those bigger than the pivot and those smaller than the pivot in the silliest way: we go through all the numbers in the array one by one and put each number in one of the three temporary arrays we make — one temporary array for numbers bigger than the pivot, one for those smaller than the pivot, and one for those equal to it.

#include<stdio.h>
#include<stdlib.h>
#define MAX_INTS 100

// Counts from zero
void printArray(int arr[], int place){
 for(int i=0;i<=place;i++){
 printf("%d,",arr[i]);
 }
 puts("");
}

// Counts from zero
// Partitions everything around the last array element (_high_ is the pivot) for elements **low** to high (not zero to high), returns the last array's (pivot's) new placement in the partitioned array.
int basicPartition(int arr[], int low, int high){
 //nE/L/H == number of equals/lows/highs
 //idx is defined at a function scope here and used later to place the elements in their correct position
 int idx=low,nE=0,nL=0,nH=0;
 int pivot=arr[high];
 int Ls[MAX_INTS]={},Hs[MAX_INTS]={},Ps[MAX_INTS]={};

 // Element enumeration
 // Here we place the numbers into temporary high, low, or equal arrays. 
 for(int i=low;i<=high;i++){
 if(arr[i]>pivot){
 Hs[nH]=arr[i];
 nH++;
 } else if (arr[i]<pivot){
 Ls[nL]=arr[i];
 nL++;
 } else if (arr[i] == pivot){
 Ps[nE]=arr[i];
 nE++;
 }
 }

 // Place from temp to arr
 for(int i=0; i<nL;i++,idx++){
 arr[idx]=Ls[i];
 }
 for(int i=0; i<nE;i++,idx++){
 arr[idx]=Ps[i];
 }
 for(int i=0; i<nH;i++,idx++){
 arr[idx]=Hs[i];
 }

 // return the new position of the pivot 
 return low+nL+nE-1;
}

// Counts from zero
int quickSort(int arr[], int low, int high){
 if(low>=high){
 return 0;
 }
 int piv=basicPartition(arr, low, high);
 quickSort(arr, low, piv-1);
 quickSort(arr, piv+1, high);
 return 0;
}

int main(void){
 int arr[] = {12,899,93,789,1000,95,4,56,11,18,12,180,43,93};
 int n = sizeof(arr)/sizeof(int);
 /* printArray(arr,n-1); */
 /* int res = basicPartition(arr, 0, n-1); */
 int res = quickSort(arr, 0, n-1);
 printArray(arr,n-1);
 return EXIT_SUCCESS;
}

If I were to draw a picture it would look like this:

The problem with this implementation is that it uses O(n) in its partitioning. How can we improve that? Maybe instead of keeping everything in a temporary array of equal size, we could do in-place replacement? That’s what the Lomuto’s partitioning algorithm does. Let’s learn that.

Lomuto’s Partitioning Algorithm

So far we made a simple partitioning algorithm, but it left much to be desired in its memory usage. If we want to use less memory, how about we swap the elements instead of keeping them in temporary arrays? That’s what Lomuto’s algorithm does. Imagine two little soldiers that we hire for sorting. The first one is named i, and the second one is named j. Our little guy i’s job is to protect the weak. He creates a firm boundary and all the elements smaller than the pivot line up before him. Our adventurous fella j’s job is to foray into the unknown, find those weaker than or equal to the pivot, and tell them they can find refuge if they line up before i. So here is how the algorithm works:

the last element of the array is chosen as our pivot
i stands at low-1, behind where the array even begins.
j stands at low, where the array begins.
j marches forward, on its way forward, it finds an element that is lower than or equal to the pivot, once it does, it stops to let i know.
j and i cooperate, i moves one step forward to mark the new boundary, the element at the new boundary is swapped with the weak/equal element.
j keeps doing this and marching on until it reaches arr[high] which is our pivot.
When j is at one step behind arr[high], we already know that arr[high] is going to be equal to the pivot since the last element is the pivot itself, so we swap arr[i+1] with arr[high] manually without doing a condition check.
At the end of the process, we return i+1, which is where our boundary (i.e. our pivot’s position in array) is after this one final swap.

Intuition: In Lomuto’s algorithm we use i as a boundary, and everything before i is smaller than or equal to the pivot. So at each step if arr[j] is smaller than the pivot we increase our boundary and move the smaller numbers inside our boundary. Now, since everything before our pivot is smaller than or equal to it and everything after that is bigger than it, our pivot is in fact in its sorted position by the definition of sort.

How does this relate to quicksort? Using Lomuto’s algorithm, you have an algorithm that efficiently partitions an array, such that one number of your array (the pivot) is already in its sorted position, and you have two separate arrays before and after the pivot, in a way that they don’t need to be compared with each other since we already know some of them are always bigger than the others. Isn’t that great? If we now ignore the pivot which is now in its sorted position and keep partitioning for arrays that come before and after it, we’ll have a fully sorted array.

Here’s my implementation of quicksort using Lomuto’s partitioning algorithm. Try not to repeat the mistakes I made during writing this code:

I used i=-1 instead of i=low-1
I swapped arr[high] and arr[i] instead of arr[high] and arr[i+1] at the last step. The boundary is at i+1, since we’re not doing that i++ which is inside our loop. Everything up to i+1 is lower than or equal to the pivot which is always at arr[i+1] at the end of the algorithm.

#include<stdio.h>
#include<stdlib.h>
#define MAX_INTS 100

// Counts from zero
void printArray(int arr[], int place){
 for(int i=0;i<=place;i++){
 printf("%d,",arr[i]);
 }
 puts("");
}

void arrSwapInt(int arr[], int a, int b){
 int temp;
 temp = arr[b];
 arr[b] = arr[a];
 arr[a] = temp;
}

// Counts from zero
int lomutoPartition(int arr[], int low, int high){
 int i=low-1;
 int piv=arr[high];
 for(int j=low;j<high;j++){
 if(arr[j]<=piv){
 i++;
 arrSwapInt(arr,i,j);
 }
 }

 arrSwapInt(arr,high,i+1);
 return i+1;
}

// Counts from zero
int quickSort(int arr[], int low, int high){
 if(low>=high){
 return 0;
 }
 int piv=lomutoPartition(arr, low, high);
 quickSort(arr, low, piv-1);
 quickSort(arr, piv+1, high);
 return 0;
}

int main(void){
 int arr[] = {12,899,93,789,1000,95,4,56,11,18,12,180,43,93};
 int n = sizeof(arr)/sizeof(int);
 int res = quickSort(arr, 0, n-1);
 printArray(arr,n-1);
 return EXIT_SUCCESS;
}

Hoare’s Partitioning Algorithm

Now let’s learn Hoare’s partitioning algorithm.

In Lomuto’s our soldiers i and j had different jobs, now they have the same job description. The only difference between i and j is that i starts one step behind the beginning of the array and j starts from one step after the end of the array. They take rounds to march on and stop where they find elements that shouldn’t be where they are. That is, first i marches towards the end of the array and stops if it sees any element that is bigger than the pivot, and then j marches towards the beginning of the array and stops if it sees any element that is smaller than the pivot. Once they’re both stopped, we can very astutely move two elements to their correct place with one swap and that’s what we do. Our soldiers i and j both keep moving until they face each other (i==j) or get past one another (i>j). That is when they know they’re done.

In short, in Hoare’s algorithm, you move from both sides to the other, stop at the wrong elements from each side, and swap them. Note that just like the two algorithms above, at the end of the Hoare’s algorithm it is guaranteed that all items left of the returned j are smaller than the pivot, and all items right of the retuned j are bigger than the pivot. But unlike those two, the pivot itself doesn’t end up at the returned j and it won’t be at its sorted position. That is, while Hoare’s partitioning algorithm returns the boundary of our partitioned arrays (j), our pivot is not at j (even though we can move it with one extra swap since we already know the boundary, we don’t do this since at the end of the recursion each element will be in its sorted position and this is unnecessary). So this time in the quicksort algorithm, we don’t do quicksort on (low,piv-1) and (piv+1,high) which ignores the element at piv, instead we do (low,piv) (piv+1,high) which includes the element at piv.

Try not to repeat the mistakes I made while writing this code:

I forgot to put the = in the loop break condition, so my code would get stuck in a loop.
I forgot to make the pivot equal to arr[low] and made it equal to arr[0].

#include<stdio.h>
#include<stdlib.h>
#define MAX_INTS 100

// Counts from zero
void printArray(int arr[], int place){
 for(int i=0;i<=place;i++){
 printf("%d,",arr[i]);
 }
 puts("");
}

void arrSwapInt(int arr[], int a, int b){
 int temp;
 temp = arr[b];
 arr[b] = arr[a];
 arr[a] = temp;
}

// Counts from zero
// Returns piv_index instead of where the pivot is
// pivot is not in its sorted position
int hoarePartition(int arr[], int low, int high){
 // low, not zero!
 int piv=arr[low];
 int i=low-1,j=high+1;
 while(1){
 do {
 i++;
 } while (arr[i]<piv);
 do {
 j--;
 } while (arr[j]>piv);
 // if you don't put the equal, for 11,4,18,13 it will get stuck in a loop since the j that is returned will be 0 instead of 1.
 // since the pivot index is the same as the one that was called, it will get stuck in a loop, unless you break when both i and j are equal
 // breaking on j==i makes sense, since if i==j then we are already done comparing boundaries and at the correct pivot index.
 if(i>=j){
 break;
 }
 arrSwapInt(arr, i, j);
 }
 return j;
}

// Counts from zero
int quickSort(int arr[], int low, int high){
 if(low>=high){
 return 0;
 }
 int piv_index=hoarePartition(arr, low, high);

 // Different from Lomuto's and basic partitioning
 quickSort(arr, low, piv_index);
 quickSort(arr, piv_index+1, high);
 return 0;
}

int main(void){
 int arr[] = {12,899,93,789,1000,95,4,56,11,18,12,180,43,93};
 /* int arr[] = {11,4,18,13}; */
 int n = sizeof(arr)/sizeof(int);
 /* int res = hoarePartition(arr, 0, n-1); */
 int res = quickSort(arr, 0, n-1);
 puts("Sorted array:");
 printArray(arr,n-1);
 return EXIT_SUCCESS;
}

Extra Tips

Pivots: In Lomuto’s algorithm, the last element (arr[high]) must be our pivot, because during the quicksort call on (low,piv-1) and (piv+1,high) we assume that the pivot is in its sorted position (that is, at the end of the boundary, where we have done our last swap), so we must choose the last element as our pivot. But if we need another array element to be our pivot, we can always swap it with the last element before we’re calling the algorithms and make the chosen element the last element. But in Hoare’s all we need is an arbitrary number that, ideally, is larger that half of the numbers and smaller than the other half, but we can choose any number really.
Best case and worse case: Running the quicksort algorithm on an already sorted array will have a time complexity of O(n^2). So we usually choose a random element as our pivot (and if it is Lomuto’s, we need to swap it and make it the last element).
Stability of the sort algorithms: The basic partitioning algorithm is stable. But neither Lomuto’s nor Hoare’s algorithms are stable, meaning that for equal items (to which we have attached extra data) the order could be changed. That is {(1,red),(2,blue),(1,blue)} could become {(1,blue), (1,red), (2,blue)}. This would be really bad if we were sorting data in a database with timestamps for example.

Conclusion

Partition Method	Pivot Choice	Extra Memory	Pivot Position After Partition	Stability	Average Time	Worst-Case Time
Basic (temp arrays)	Doesn’t matter	O(n)	Pivot(s) end up in the middle of the concatenated lows-equals-highs block	Yes	O(n log n)	O(n²)
Lomuto	Must be the last element	O(1)	Pivot placed at its final sorted index (i+1)	No	O(n log n)	O(n²)
Hoare	Doesn’t matter but usually the first element	O(1)	Pivot not guaranteed in final position; partitions around boundary j	No	O(n log n)	O(n²)

Did you see what we did for sorting? There is much to be learned from what we did here. We used Divide and Conquer to solve our problem. At each section we only had an algorithm that could do a single sort (a partitioning algorithm can put at most one element in its sorted position) but we used this algorithm - which can’t be seen as a sorting algorithm - 1. multiple times and 2. on smaller and smaller subsets of our problem, so at the end sorting happened efficiently. Any time you’re thinking about a problem that can’t be solved efficiently, maybe you could think about single items and then use D&C to solve the problem.

TODO

I asked AI what I should learn next and here are its opinions:

You never mention the importance of pivot choice on expected running time or practical performance (cache behavior, branch prediction, etc.). Real-world quicksort typically uses “median-of-three” or introspective quicksort (Introsort) that switches to heapsort if recursion gets too deep.
Neither Lomuto’s nor Hoare’s implementations do tail recursion elimination. In the worst case (unbalanced splits), your recursion depth is O(n) and you risk a stack overflow. Best practice is to recurse on the smaller subarray first, then iterate on the larger one.
Discuss three-way partitioning for many-duplicate inputs. And I think I should:
Add pictures of our valiant soldiers i and j performing their duties in Lomuoto’s and Hoare’s algorithms.

Dining Cryptographers

hossein@naghdbishi.com (Hossein Naghdbishi) — Sat, 26 Jul 2025 01:02:24 +0330

Today I learned about the Dining cryptographers problem. It is such a great usage of XOR!

Suppose we have three cryptographers-a,b and c- seated in a circle. They all flip a coin and see the coin of the person sitting to the right of them. The goal: anonymously signal “I paid” (bit 1) or “Nobody paid” (bit 0) by publicly announcing XORs of coin flips, without revealing who paid. One of them can relay a message by saying the opposite of what the protocol usually expects. If a b and c gather round a table here's how everyone's positioned:

 a
b c

for a: a XOR c

for b: b XOR a

for c: c XOR b

Now you can easily see that if a, b and c toss a coin, and always say truth about the XOR of their coin's state with the state of their neighbour's coins, the result is always 0 because each element cancel itself out. That is: (a XOR c) XOR (b XOR a) XOR (c XOR b) is always zero. However if any of them want to say that a state is true (that at least one of them has paid for the dinner instead of the NSA for example) they can do so by opting to announce the NOT of their XORs instead. That way the answer would be 1, a message has been collaborated to the whole group, however the sender of the message is private. But the problem is that there can be only one sender, and one bit at each round to be sent.

How to Convert Telegram Stickers to Signal

hossein@naghdbishi.com (Hossein Naghdbishi) — Mon, 26 May 2025 23:29:20 +0330

As Telegram is one of the most used messengers in Iran, it has a large pool of stickers. I don’t want my contacts to miss out on them, so I always try to bring good stickers to Signal. Luckily there is an awesome free (libre) app named sticker-convert that takes care of this.

I use its command line version like this:

./sticker-convert-x86_64.AppImage --download-telegram https://t.me/addstickers/GreatMindsColor --author 'None' --title 'None' --export-signal --signal-uuid UUID --signal-password 'PASSWORD' --telegram-userid USER_ID --telegram-token 'TELEGRAM_TOKEN'

Now there is good documentation on how you can find and generate the tokens for both Signal and Telegram. But for better security, I enter fake Signal credentials and provide only a bot token to the script. Obviously the script throws out an error, but the APNG output is there. So you can easily use Signal Desktop (File menu -> Create/upload sticker pack), import the APNG files into it, and upload them. The only downside is that the script takes care of emojis automatically, but you have to enter them manually if you use Signal Desktop for importing APNG files.

After you’re done converting the stickers, please make sure you share them on https://signalstickers.org as well with good tags, so everyone can easily find and use them.

The Secret Interplay Between OpenSnitch and nftables

hossein@naghdbishi.com (Hossein Naghdbishi) — Wed, 16 Apr 2025 12:20:13 +0330

I use NixOS and I have enabled its networking.nftables.enable = true; and networking.firewall.enable = true;. This means I get to use the default configuration of nftables on NixOS. Now, there are times when I wish to disable it. It is fairly easy to stop the firewall service: systemctl stop nftables does it. This automatically flushes the nftables ruleset and gives me freedom to do whatever I want.

Today, I wanted to run a small Debian VM, and I was in no mood to configure its networking, using QEMU’s SLiRP was the way. After creating the appropriate cloud-init files, here’s the command I ran:

qemu-system-x86_64 \
 -m 2048 \
 -smp 2 \
 -drive file=debian-12-genericcloud-amd64.qcow2,format=qcow2 \
 -netdev user,id=net0,hostfwd=tcp::2222-:22 \
 -device virtio-net,netdev=net0 \
 -nographic -drive file=cloud-init.iso,media=cdrom

But strangely, there was no Internet access inside the VM except for ICMP packets. Everything went fine when I flushed the nftables ruleset, but even after stopping nftables, no matter how many times I flushed the table via nft flush ruleset, these two tables kept coming back in a matter of seconds:

table inet mangle {
 chain output {
 type route hook output priority mangle; policy accept;
 meta l4proto != tcp ct state related,new queue flags bypass to 0
 tcp flags & (fin | syn | rst | ack) == syn queue flags bypass to 0
 }
}
table inet filter {
 chain input {
 type filter hook input priority filter; policy accept;
 udp sport 53 queue flags bypass to 0
 }
}

What could it possibly be? At the first step, I learned about what queues are for in nftables. I had never seen them before. Queue statements in nftables are used to pass packets to userspace, just at that moment I knew which application it was. I use OpenSnitch to monitor which applications make what requests. OpenSnitch automatically added all these rules, no matter how many times I flushed the ruleset. As a program that needs to process packets, it makes sense for OpenSnitch to check for its rules, but it seemed frightening at first, when I didn’t know what was going on.

I was under the assumption that using eBPF, all packets are checked under OpenSnitch, but apparently only TCP packets with SYN flag, and new and related packets of other type are sent to OpenSnitch for further processing. Could a person use this to their advantage? If they have root access and can send malformed packets to initiate connections, then I guess so.

Hosting a Hugo Site Using Codeberg Pages with One-Click Deployment

hossein@naghdbishi.com (Hossein Naghdbishi) — Sat, 12 Apr 2025 12:41:00 +0330

How to host a Hugo site using Codeberg Pages with one-click deployment?

Yesterday I made a few changes to my site, namely I decided to merge my Persian and English blog into one, and write more blog posts.

To write more, it is necessary for the act of publishing a blog post to be easy. It would be easy on Github, which has its own CI, but I don’t want to host my blog there (they’re not a big help to libre software). Not using Github means I lose access to a nice CI. I could request one from Codeberg but seeing that it’d take their resources I decided against that as well.

Using Bash for Automatic Deployment

To automate a series of repetitive shell commands, the ever-present bash is the first option to consider. So that’s what I went with.

My blog is on a single repo, but has two different branches. This meant that I had to go through some extra loops (git switch, git clean, …) to publish my blog. Wouldn’t it be nice if I could have both my branches, my source directory and its build results in separate directories? A simple yet stupid approach is to clone the repo twice and use each branch in a different folder. However the best practice is to use git worktrees. And that’s what I went with.

First we need to create one directory for each of the branches. You can learn this trick from here. Note that you may have to also allow for relative paths (git config status.relativePaths true) if you’re moving the base folder around, or use the same folder on multiple devices (for example by using Syncthing).

After being done with the process, you will have this directory structure:

.
├── deploy.sh
├── main
└── src

Make sure to go inside each worktree and do a git pull. You may need to set up upstream branches as well.

Then you can run the following deployment code for deploy.sh when you’re in the parent directory:

set -ux

BOLD="\e[1m"
RED="\e[31m"
RESET="\e[0m"

echo -e "${BOLD}${RED}Make sure to push to src, as it does not happen automatically${RESET}"


echo "Currently at $PWD"
cd src
echo "Removing old files"
rm -rf ./public/*
echo "Building..."
hugo build
cd ..
cd main
echo "Removing all files in main"
rm -rf *
if [ ! -f .domains ]; then
 echo "Error: File '.domains' does not exist."
 exit 1
fi
echo "Restoring main"
cp -r ../src/public/* .
echo "Git add"
git add .
echo "Git diff, do you verify?"
git diff HEAD

COMMIT_MESSAGE="${1:-$(git -C ../src log -1 --pretty=%B)}"
echo "Using $COMMIT_MESSAGE as commit message."

read -p "Do you want to continue? (y/n): " answer
if [[ "$answer" == "n" ]]; then
 echo "You said no. Exiting..."
 exit 0
elif [[ "$answer" == "y" ]]; then
 echo "Continuing..."
else
 echo "Invalid input. Please enter 'y' or 'n'."
 exit 1
fi
echo "Git commit..."

git commit -m "$COMMIT_MESSAGE"

echo "Git push..."
git push

With this setup, I push to the src branch manually, but I can then easily deploy the static build results locally without using any CI tooling.

Make Capslock Great Again: XKB Customization for Sway

hossein@naghdbishi.com (Hossein Naghdbishi) — Sun, 26 May 2024 01:20:00 +0330

As I’m on the unstable branch of NixOS, one day I woke up to a NixOS config that was failing to build. Specifically, the derivation for sway.conf wouldn’t build. The keyboard layout I use is special. I usually switch between two customized keyboard layouts. I use the Dvorak layout to write English, and Persian (with Persian numpad) as my second layout. All my attempts to use my previous config, where I just put two modified xkb_symbol files in ~/.config/xkb/ failed. I used to have some line like this in my Sway config: xkb_layout = "us_with_vim,ir_with_vim".

But now the only option that I could use without NixOS throwing an error at me was the xkb_file which, as explained in sway-input(5), this option overrides the two previous options that I was using.

It was hard to find an xkb_file example with two layouts in it on the web. So, here you are, a XKB keymap that I wrote that not only has two layouts in it, but also makes capslock great again by changing capslock+hjkl into arrow keys. Also, the numpad is never turned off.

xkb_keymap {
 xkb_keycodes { include "evdev+aliases(qwerty)" };
 xkb_types { include "complete+numpad(mac)" };
 xkb_compat { include "complete" };
 xkb_symbols {
 include "pc+us(dvorak)+inet(evdev)+group(alts_toggle)"
 name[Group1] = "dvorak with vim";
 
 include "ir(pes_keypad):2+group(alts_toggle):2"
 name[Group2] = "persian with vim";

 // Changes for us(dvorak)
 key <CAPS> {
 type= "TWO_LEVEL",
 symbols[Group1]= [ ISO_Level3_Shift ],
 symbols[Group2]= [ ISO_Level3_Shift ]
 };

 key <AC02> {
 type= "FOUR_LEVEL",
 symbols[Group1]= [ o, O, KP_Enter, KP_Enter ],
 symbols[Group2]= [ Arabic_seen, Arabic_hamzaonyeh, KP_Enter, KP_Enter ]
 };

 key <AC03> {
 type= "FOUR_LEVEL",
 symbols[Group1]= [ e, E, Next, Next ],
 symbols[Group2]= [ Farsi_yeh, Arabic_yeh, Arabic_alefmaksura ]
 };
 key <AC04> {
 type= "FOUR_LEVEL",
 symbols[Group1]= [ u, U, BackSpace, BackSpace ],
 symbols[Group2]= [ Arabic_beh, Arabic_hamzaunderalef, BackSpace, BackSpace ]
 };
 key <AC06> {
 type= "FOUR_LEVEL",
 symbols[Group1]= [ d, D, Left, Left ],
 symbols[Group2]= [ Arabic_alef, Arabic_maddaonalef, Left, Left ]
 };
 key <AC07> {
 type= "FOUR_LEVEL",
 symbols[Group1]= [ h, H, Down, Down ],
 symbols[Group2]= [ Arabic_teh, Arabic_tatweel, Down, Down ]
 };
 key <AC08> {
 type= "FOUR_LEVEL",
 symbols[Group1]= [ t, T, Up, Up ],
 symbols[Group2]= [ Arabic_noon, guillemotright, Up, Up ]
 };
 key <AC09> {
 type= "FOUR_LEVEL",
 symbols[Group1]= [ n, N, Right, Right ],
 symbols[Group2]= [ Arabic_meem, guillemotleft, Right, Right ]
 };
 key <AD07> {
 type= "FOUR_LEVEL",
 symbols[Group1]= [ g, G, Prior, Prior ],
 symbols[Group2]= [ Arabic_ain, Arabic_fatha, Prior, Prior ]
 };
 key <AD08> {
 type= "FOUR_LEVEL",
 symbols[Group1]= [ c, C, Delete, Delete ],
 symbols[Group2]= [ Arabic_heh, Arabic_shadda, Delete, Delete ]
 };
 key <AE03> {
 type= "FOUR_LEVEL",
 symbols[Group1]= [ 3, numbersign, Home, Home ],
 symbols[Group2]= [ Farsi_3, 0x100066b, Home, Home ]
 };
 key <AE04> {
 type= "FOUR_LEVEL",
 symbols[Group1]= [ 4, dollar, End, End ],
 symbols[Group2]= [ Farsi_4, 0x100fdfc, End, End ]
 };
 };
 xkb_geometry { include "pc(pc105)" };
};

Update (May 2025):

Don’t use sway? You can use keyd with the following /etc/keyd/default.conf:

[ids]
*

[main]
# Define capslock behavior:
# - When held with another key, activate the 'nav' layer.
# - When tapped alone, behave as normal capslock.
capslock = overload(nav, capslock)

[nav]
h = left
j = down
k = up
l = right
f = backspace
backspace = delete

Buddhism

hossein@naghdbishi.com (Hossein Naghdbishi) — Fri, 24 Nov 2023 18:33:58 +0330

Gautama found that there was a way to exit this vicious circle. If, when the mind experiences something pleasant or unpleasant, it simply understands things as they are, then there is no suffering. If you experience sadness without craving that the sadness go away, you continue to feel sadness but you do not suffer from it. There can actually be richness in the sadness. If you experience joy without craving that the joy linger and intensify, you continue to feel joy without losing your peace of mind.

But how do you get the mind to accept things as they are, without craving? To accept sadness as sadness, joy as joy, pain as pain? Gautama developed a set of meditation techniques that train the mind to experience reality as it is, without craving. These practices train the mind to focus all its attention on the question, ‘What am I experiencing now?’ rather than on ‘What would I rather be experiencing?’ It is difficult to achieve this state of mind, but not impossible.

Gautama grounded these meditation techniques in a set of ethical rules meant to make it easier for people to focus on actual experience and to avoid falling into cravings and fantasies. He instructed his followers to avoid killing, promiscuous sex and theft, since such acts necessarily stoke the fire of craving (for power, for sensual pleasure, or for wealth). When the flames are completely extinguished, craving is replaced by a state of perfect contentment and serenity, known as nirvana (the literal meaning of which is ‘extinguishing the fire’). Those who have attained nirvana are fully liberated from all suffering. They experience reality with the utmost clarity, free of fantasies and delusions. While they will most likely still encounter unpleasantness and pain, such experiences cause them no misery. A person who does not crave cannot suffer.¹

Sapiens: A Brief History of Humankind, Sapiens: A Brief History of Humankind ↩︎

VPS Troubleshooting: A Quick Guide

hossein@naghdbishi.com (Hossein Naghdbishi) — Sun, 14 May 2023 18:10:53 +0330

Many problems may occur on a VPS, and solving them is no easy task. It’s like being a doctor, you can only see the symptoms and have to give educated guesses about what the cause of the problem may be.

First you diagnose the problem by different tools you have. Then, depending on your guess about the root cause, you try different remedies until you find one that actually solves the problem.

This article will go over some general problems that VPSes may have. We will also learn how one may solve them. Let’s go!

Unable to connect to the server via SSH

Use the web console.

All VPS providers give you the ability to manage your VPS even if it doesn’t have an Internet connection. Find that section (usually called web console) in your VPS provider’s site and log in to your server, follow the rest of the article then.

Are you connecting to the correct port and IP?

Check the IP you’re trying to connect to; is it the same as the one on your VPS provider site? If so, the problem may be that you’re trying to connect to the wrong port.

First, try to see the port that your SSH server listens to. You can use this command on your server to find that out: sudo ss -tulpn | grep ssh if it shows any port other than 22, try connecting to that port from your PC, for example for port 2222, we’ll have ssh -p 2222 user@IP

Is your sever up and running?

If you haven’t blocked ICMP packets with your firewall, you can use ping (or if you only have IPv6, ping6) to see whether your server is accessible over the Internet. Try: ping x or ping6 y where x is your IPv4 and y your IPv6 address.

Can you ping your server? Or, equivalently, can you open a service hosted on it? If so, it’s good news! At least now you know that the OS on the server is up and is responding to the packets it receives. If it’s not, ping your server with online tools such as ping.pe to make sure your server is really down, and it’s not a problem specific to your PC. If your server is down, you must reach out to your VPS provider. It’s most likely that they have turned off your VPS because you haven’t payed the bills, if it’s not that, then open a ticket and ask them for help.

Use another server or computer for SSH connection

If your server’s up, but you can’t SSH to it, it may be your PC’s Internet connection that has problems. Try SSHing on other servers or computers and see if the problem’s on your server’s side. Ideally, you can use tcp.ping.pe to verify that your server’s SSH port is open from multiple locations.

Use the verbose mode of SSH

Your SSH client itself can provide you with more details if you ask it to, use the -vvv

option for the SSH command, it’ll become more verbose and you may find the problem just by doing that.

Is your firewall allowing TCP packets to that port?

It may be that you have enabled a firewall and it’s drops any packets sent to the port SSH server is currently listening to. It all really depends on your distro, or the firewall you have chosen to use, but on most distros, iptables is the default firewall, so try: sudo iptables -L

If you have installed nftables, try this one: sudo nft list ruleset

There must be nothing that indicates dropping of packets on the port that your SSH server is listening to. If there is, just change the configuration so that it allows TCP packets to that port.

Is your SSH server configured well? Is it running?

Sometimes it’s not about the firewall, it’s just that there’s no SSH server listening on any port, or if there is, it’s not allowing you to log in. Most GNU/Linux distros use OpenSSH as their SSH server and manage it with systemd. I’ll assume these tools for this article, but for example Alpine Linux and Gentoo use openrc and not systemd, or some may use dropbear as their SSH server. Keep these differences in mind if you’re not using mainstream distros such as Ubuntu and Debian.

First let’s see if your SSH server is running with no problems. As before, ss -tulpn | grep ssh will show if there’s a process with ssh in its name is running and listening to any port. OpenSSH’s server part is called “sshd” so if it’s listening it will show up.

If it’s running but you can’t connect to it; or if it’s not running, you can look for some simple logs using this command: journalctl -u ssh.service

If you can’t diagnose and solve the problem just by reading those logs, try looking up OpenSSH logs directly. You can do this by executing cat /var/log/auth.log if this doesn’t work, try cat /var/log/secure

This book will help you understand what the log is saying.

After reading logs and searching about them, you should have a general sense of what’s wrong with your sshd configuration, if you need to change anything, try using sudo nano /etc/ssh/sshd_config After saving your changes to this configuration file, run sudo systemctl restart sshd for the changes to take place, repeat reading logs and making changes until you have a working SSH server.

Some lines that you must pay attention to are:

PermitRootLogin If it’s “no”, then obviously you can’t log in as root and should try logging in as other users.
PasswordAuthentication If it’s set to no, you have to always log in using your private key (a good thing!). This is done by -i option in your ssh client: ssh -i /path/to/privkey
PubkeyAuthentication This must be set to yes if you’re trying to authenticate yourself by a private key as shown above.
ListenAddress This part specifies on which ports the SSH server listens to. Any IP other than 0.0.0.0 (and it’s IPv6 counterpart ::) or the IP you’re currently SSHing to will cause the packets to drop since the IP you request and the IP the SSH server is listening to don’t match.

To check if the SSH server is running you can try: sudo systemctl status sshd

High CPU usage

A one-shot or a chronic problem?

Look at the CPU usage graph of your VPS. You either have server monitoring tools such as Prometheus, or if you don’t, just use the one your VPS provider (probably) gives you.

In the graph, if you see a sudden bump, it may be that you have suddenly too many people using your services, your VPS has a malware, or that you’re under a DDoS attack. For the latter, using a CDN is a good idea.

If the graph is smooth and showing consistently high CPU usage, follow the steps below. If the processes that are using lots of CPU are legitimate, think about upgrading your VPS resources.

Find the CPU-consuming processes.

You can see which processes are using the most CPU by executing: sudo top -o %CPU. You can find the culprit here. Once found, you can kill it or renice it. If the process is critical, you shouldn’t do either, just upgrade your VPS resources.

To kill a process, press k while top is open. It will ask you for a process ID (PID) and it will close that process for you.

Instead of killing processes, you can renice them. Linux comes with the ability to change the priority of processes in CPU scheduling. It’s called renicing. While top is running press r , then enter a PID and change its nice value. The nice value indicates the priority of the processes in getting CPU time. Nice can be any value from +19 to -20, the higher it is, the less CPU resource that process will get. When you’re done, press q to quit.

Kill, restart, or renice the processes

If you don’t find the CPU consuming processes critical, kill them. To kill a process, press k while top is open. It will ask you for a process ID (PID) and it will close that process for you. If they don’t go away gracefull, press q to quit from top, then execute kill -9 x where x is the PID. This will force kill the process. You can try restarting the services that run the processes (e.g. if nginx uses too much CPU: systemctl restart nginx).

Instead of killing or restarting processes, you can renice them. Linux comes with the ability to change the priority of processes in CPU scheduling, it’s called renicing. While top is running press r , then enter a PID and change its nice value. The nice value indicates the priority of the processes in getting CPU time. Nice can be any value from +19 to -20, the higher it is, the less CPU resource that process will get. When you’re done, press q to quit.

Case-by-case solutions

Sometimes the problem is more subtle, a misconfiguration in, for example, your MySQL server, or a badly written Wordpress plugin might be the whole reason your VPS is consuming so much CPU. If you have a guess about the culprit (that shows up in the result of top command), try searching. Other users may have the same problem with the service, and you can ask them about how they have solved the issue.

Updating everything

If the problem persists, try updating everything (from your entire OS to every docker container) as a last shot. If you have recently installed or upgraded something and guess that may be the cause, you can downgrade or reinstall that too.

Unexpected reboot

This one’s hard to catch! But let’s try.

How frequent are these reboots? and when do they happen?

First see your uptime, use the uptime command, it will show you the current time and following that, how long your system has been up.

Then try to see the frequency of the reboots. You can do this by: sudo last -x | tac the | tac part is optional and only shows you the latest info at the bottom of the terminal, instead of at the top.

You may understand at this level that your system is not facing a reboot, it may just be that OOM killer is killing your processes because you’re running out of memory and your process doesn’t restart automatically.

Look through the logs

After you get a rough idea of the times your server reboots, it’s time to dive into the logs. Try checking out either /var/log/messages or /var/log/syslog. Since you know exactly when you have had reboots and these files have timestamps, you know where you should look at. You can also use cat and grep to look for specific keywords.

Mae sure you look into journalctl logs at a little bit before and after reboots using this command: journalctl -S "2023-01-01 00:00:00" -U "2023-01-01 01:00:00"

Things get a lot easier once you use the journalctl command, first list the boots you have had by journalctl --list-boots there will be a list of latest boots with a descending number assigned to each of them. If you want to see the logs for your current boot (which has the number 0) You would type: journalctl -b 0 and for the one before that journalctl -b -1 and so on (src). Please note that journalctl uses a pager. Use arrow keys to navigate, but if you want to jump to the latest logs just press Shift+g.

Check for common culprits

Linux sometimes panics, and if you make it to, it will reboot on panics. You can see if this is the case by executing sysctl kernel.panic. If the result is a negative number, Linux will immediately reboot after a panic, if it’s a positive number, it will reboot after that many seconds, and if it’s 0, it won’t reboot.

If you’re using a Debian based distro, and have enabled Unattended-Upgrade::Automatic-Reboot in your apt configuration, then apt will reboot the system on its own after upgrades.

Are you running out of resources? Check for that too, in the following part of the article you’ll learn how.

Ask for your VPS provider’s uptime

There may be nothing with your VPS after all, maybe it’s just that the dedicated server hosting your server is not configured well, or that it’s having reboots, ask your VPS provider about this.

Slow response time / network connection instability

Do you have enough CPU/Disk/RAM resources?

Network packets need to be processed, if your system is overwhelmed and there’s not enough RAM and CPU, your VPS may have problem with processing the incoming packets. So use the following commands to see how much available resource you have.

free -h use this to see how much RAM and swap you have left.
top see which processes are hogging resources
df -h see if you have enough space left. The usage percentage better be less than 98%.
df -hi see how much inodes you have left on each partition. The usage percentage better be less than 98%.

You may wonder what disk has got to do with response time. Two things come to mind. First, your programs need disk space to function well (for example a SQL server needs to write to disk) and second, sometimes your RAM is full and the OS starts writing to swap, if there’s too much I/O going on, writing and reading may be slow and it will hurt all the running processes that use swap. You should not lean on swap and if it’s always full, just buy more RAM.

Is your hard disk’s I/O speed okay?

Sometimes the root of slow response time lies within slow disk read and write. Check for that as well.

Is your network okay?

Sometimes it may not be that your provider is having problems, but that your server is being flooded with network requests. You can check that out an app called nethogs. If you’re using too much network resources, ask for a dedicated Internet port from your server provider. But if you’re not, try to see what’s happening under the hood.

Try pinging yourself and some other IP: ping -c 10 your_ip and ping -c 1.1.1.1. Ping shows you how long (in milliseconds) a server takes to respond to your packets, the less it is, the better. Pinging yourself should take less than a millisecond and pinging 1.1.1.1, less than 200ms at most, although it usually is a lot less than 200ms. Other than average round trip time that is displayed at the bottom, there’s also another factor you should pay attention to: packet loss. Ideally you should have a 0% packet loss.

Try testing your Internet speed, first install speedtest-cli and then run it. Depending on your VPS provider’s network and what plan you have bought, the speed you get will vary, but if it’s too slow (and other processes are not downloading anything either), open a ticket with your provider.

Check for software issues

If your network connection is okay, but you’re still having slow response time, then it’s time that you look into the configuration of the specific service that is slow, try searching about that specific piece of software, and then optimize it.

Summary

In this article we went through some of the common problems that you may face by owning a VPS, introduced some diagnostic tools for the problems and offered solutions. I hope you find them useful. If you have any questions or comments, don’t hesitate to send me an email.

Hypothesis Testing, P-Value: Things We Learn From an Anime

hossein@naghdbishi.com (Hossein Naghdbishi) — Mon, 07 Mar 2022 16:14:30 +0330

They say it is only everybody that knows almost everything and I agree. I rarely claim to know about a concept. The only thing that I’m certain about, is that there is always something, somewhere about that concept that I don’t know. But this is good news, this means that there’s always room for learning more, and I can keep learning and understanding.

Hypothesis testing is one of the pillars of scientific discoveries. After observations, hypotheses are made, and surely, they need to be tested one way or another. Let’s try to understand what it takes to test a hypothesis.

The way I’m going to structure this post and demonstrate how the statistics behind scientific discoveries works, comes from an unlikely source. In its first episode, the 2020 anime Science Fell in Love, So I Tried to Prove It, demonstrates the essence of hypothesis testing in a way none of my professors could. What I do here is building upon that demonstration and adding a very small amount of R and mathematical mojo.

Suppose you’re a scientist living in a magical land and you want to prove that all the crows in this magical land are black, however your magical powers can only take a random sample of 100 crows and this can happen only once. You cast the spell, out of all the crows in the land, a random sample of 100 crows appear in front of you and you check them: they are all indeed black.

Does this mean you can victoriously claim that all crows are black? You know very well that any critic, even you yourself, can always say that you have reached this conclusion, only because of your limited powers of magic, because of the small sample size, and not because all the crows are black like you’re implying. How do you know that there wouldn’t have been a crow of a different color, had your magical powers enabled you to take a larger sample of the crows of the land? This is a question to be considered. ¹

Does your limited powers of observation mean that you can claim nothing unless you can do a full survey of all the crows in the world? Not really; even with limited powers of random sampling, you can still make very reliable claims using probabilities and contradiction.

To any critic, you can say, alright, probably you’re right, perhaps not all crows are black. What percentage of crows do you claim to be non-black? Let’s say they suggest that 50% of the crows are not black.

But if this is the case, given that your sample is truly randomly chosen, you can calculate the possibility of getting such a sample from a population of crows that one half of it is black, and the other half is not.

A crow can be either black or not. If we were dealing with just choosing one random crow from the population, we’d have a distribution called the Bernoulli distribution, since we have multiple crows drawn out from the population, we’re dealing with a Binomial distribution. In the formula below, p is the chance that a crow is black, k is the number of time’s we’ve seen a black crow in our sample and n is the total number of the times we’ve drawn out a crow from the population.

\[ P(X=k)=\binom{n}{k}(p)^k(1-p)^{n-k} \]

Here’s the chance of getting 100 black crows given that half of the crows are black and the other half are not:

\[ P(X=100)=\binom{100}{100}(\frac{1}{2})^{100}(\frac{1}{2})^{0}\approx 7.888\times10^{-31} \]

This small values doesn’t sound very probable, does it?

You can even see it on the graph, the likelihood of getting 65 crows that are all black in this scenario is very unlikely, let alone 100 crows that are all black.

We’d get the same improbable results unless the critic increases their evaluation of the portion of crows they think are black. Let’s say they argue that, yes, most crows are black but there’s a very small portion of crows that are non-black, and this rarity is why we have missed the non-black ones.

For example they might say that only 4% of the crows are non-black and that’s why our sample of 100 has missed them.

We can argue, once more, that even this time the chances that we have missed the non-black crows because of the sample size is really low, the probability that a random sample of 100 black crows happens merely by chance, given that 4% of the crows of the population are non-black_is less than 1.7%.

\[ P(X=100)=\binom{100}{100}(0.96)^{100}(0.4)^{0}\approx 0.01687 \]

If they’re smart enough, they can suggest a portion that actually undermines our findings, here’s how:

\[ P(X=100)=\binom{100}{100}(p)^{100}(1-p)^{0} = 0.05 \]

\[ p^{100} = 5 \times 10^{-2} \Rightarrow p=5^{\frac{1}{100}} \times 10^{\frac{-2}{100}} \approx 0.9705 \]

A binomial distribution with n=100 and p=0.9705 looks like this:

If they claim that 97.05% crows are black, now our sample size begins to make problems, the probability that a random sample of 100 black crows happens, given that 97.05% of the crows of the population are black is around 5%.

The sentences above in italic tell us what p-value means for our question. But we can state it in a more general form: it’s the probability that our sample (or what’s even more extreme than our sample) happens, given that the hypothesis we tried to contradict is true.

\[ p-value=P(\mbox{occurrence of our sample or more extreme case}|H_0) \]

The use of contradiction happens right here: If this probability is very low, then maybe what we’re assuming is wrong? In different branches of science, 5% is what we call really low probability. If for our null hypothesis, our p-value drops to anything less than 5%, we say:

We reject the null hypothesis, in favor of the alternative hypothesis at the significance level of 5%

There are two important points to be made here. First: failing to reject the null hypothesis doesn’t mean it’s true, because you’re already assuming the null hypothesis in the calculations. It doesn’t make a whole lot of sense to accept the null hypothesis when you’re already assuming it. Null hypothesis can never be accepted, we can only reject it at a certain significance level or fail to reject it and that’s it.

The other point is that here we worked with the most extreme case, had we chosen another statement as our hypothesis, we would have to consider both our own case and the extremer ones to calculate the p-value.

At last, I encourage you to read about p-hacking and what it means for science in general. From what I’ve come to understand p-value is a great tool, but it can also be misused and misunderstood .

And oh… One more thing! Search for “p-value memes” or “null hypothesis memes” in your favorite web search engine, and have fun :)

How to Study

hossein@naghdbishi.com (Hossein Naghdbishi) — Fri, 14 Jan 2022 16:06:41 +0330

See here.

Lately I’ve been thinking of becoming even more serious in my goal of becoming a researcher. Mainly I’ve been asking myself: how many hours of studying is enough? The article above has some valuable tips and also answers this question.

These two are great too: + +.

Kant

hossein@naghdbishi.com (Hossein Naghdbishi) — Fri, 08 Oct 2021 16:01:36 +0330

Lately I’ve been reading a little bit about Kant, mainly Roger Scruton’s book: “Kant: A Very Short Introduction”. Here I intend to briefly explain things I find interesting about him.

Two things fill the mind with ever new and increasing admiration and reverence, the more often and more steadily one reflects on them: the starry heavens above me and the moral law within me. I do not need to search for them and merely conjecture them as though they were veiled in obscurity or in the transcendent region beyond my horizon; I see them before me and connect them immediately with the consciousness of my existence. The first begins from the place I occupy in the external world of sense and extends the connection in which I stand into an unbounded magnitude with worlds upon worlds and systems of systems, and moreover into the unbounded times of their periodic motion, their beginning and their duration. The second begins from my invisible self, my personality, and presents me in a world which has true infinity but which can be discovered only by the understanding, and I cognize that my connection with that world (and thereby with all those visible worlds as well) is not merely contingent, as in the first case, but universal and necessary. The first view of a countless multitude of worlds annihilates, as it were, my importance as an animal creature, which after it has been for a short time provided with vital force (one knows not how) must give back to the planet (a mere speck in the universe) the matter from which it came. The second, on the contrary, raises my worth as an intelligence infinitely through my personality, in which the moral law reveals to me a life independent of animality and even of the whole sensible world, at least so far as this may be inferred from the purposive determination of my existence by this law.

This is the most famous quote from Kant which, as Paul Guyer puts it, contains within itself references to two of the Kant’s greatest accomplishments in philosophy: his ideas about metaphysics and his ideas about ethics.

What does Kant have to offer? He has already answered this question:

All interest of my reason (the speculative as well as the practical) is united in the following three questions:

What can I know?

What should I do?

What may I hope?

Kant was born in 1724. He went on to become one of the greatest thinkers of the Enlightenment era.

During this era, thanks to the confidence brought by the great achievements of Newton, much emphasis was put into human reasoning. If one were to substitute, or even support, traditional authorities through reason, two basic disciplines were needed. First, if we’re going to ever do scientific experiments, or use their results, we need to determine whether knowing anything about this world is possible at all (since my whole world may be an illusion made by an evil demon after all). It’s obvious then, that we need a philosophy of epistemology. Secondly, if we are not going to rely on religion, we’re going to need another moral compass. A philosophy of ethics is then needed. Kant has came up with solutions in both areas.

During the Enlightenment two main views were prevalent: Empiricism and Rationalism. Empiricists like Hume, threatened the foundations of science in a way. They had posited that we can’t have any knowledge of the world except through our own experience, and that our knowledge is always limited to our very own experience of the world. Leibniz and other rationalists however thought that the knowledge can be derived from reason independent of sensation and experience. Kant takes the middle way. He argues that knowledge is impossible without both our sensory input and our capacity to understand. Reason offers forms without content and sensation content without form. If I see something and call it a chair, it’s because I’ve used both the sensory input and my capacity to reason.

What I like most about Kant is his creativity. For example in case of epistemology, empiricists claim that no knowledge can be possible that is not from my perspective, so it’s impossible for me to come up with a universal fact. They ask how is synthetic a priori knowledge (knowledge that offers something new about the world that is both universal and necessary) possible? Kant says it’s true that nothing can be said about the intelligible world, but what if we investigate what’s possible to say about the sensible world? He then goes on to show how synthetic a priori knowledge is possible in this case. He calls this “Copernican revolution in philosophy”.

What Kant comes up with ultimately is nothing but what commonsense usually offers. For epistemology He tries his best to prove that things are as we see them and we see as they are. The same inclination towards commonsense is also true for his philosophy of ethics. Good will is central to his ethics.

It is impossible to conceive anything at all in the world, or even out of it, which can be taken as good without qualification, except a good will.

It’s an enormous task to provide philosophical grounds for what we have in ourselves intuitively, but what’s more interesting about Kant is how derives most of the information he needs from very basic ideas. He answers most of the questions of epistemology by examining the presuppositions of the simple fact that we can ask the question “How is synthetic a priori knowledge possible?”, and for ethics he utilizes a basic claim of “Ought implies can” to get what he wants.

I talked mostly about Kant’s ideas about metaphysics. Kant’s ethics is a lot more interesting indeed but you don’t need me to explain it to you, there are experts that explain it a lot better than I ever could.

While I can’t claim to have understood him, I’m glad I took the time to read about him and his ideas. I am less interested in metaphysics, so my next goal would is to read more about ethics in general.

Next book: Ethics for Dummies.

Photo by ESO/A. Fitzsimmons licensed under CC BY 4.0 ↩︎

Happiness Science

hossein@naghdbishi.com (Hossein Naghdbishi) — Fri, 20 Nov 2020 15:57:05 +0330

Watch this great video

Stoicism Is Awesome But...

hossein@naghdbishi.com (Hossein Naghdbishi) — Fri, 22 May 2020 15:48:23 +0330

Stoicism is an awesome philosophy, one that I’ve spent some time reading about. Today however I was searching for what critics have to say. I stumbled upon this piece from New Ideal which preaches Ayn Rand’s thoughts.

When Stoic philosophers utter sentences like “If you’re a slave then be a good slave.”, you don’t have a choice but to think that the underlying determinism in Stoicism is way too strong, and one should make way for what other philosophies have to say too: Every person is responsible for his or her own happiness and should try to pursue it.

What Makes Us Happy

hossein@naghdbishi.com (Hossein Naghdbishi) — Mon, 06 Apr 2020 15:39:07 +0330

Vaillant says his hopeful temperament is best summed up by the story of a father who on Christmas Eve puts into one son’s stocking a fine gold watch, and into another son’s, a pile of horse manure. The next morning, the first boy comes to his father and says glumly, “Dad, I just don’t know what I’ll do with this watch. It’s so fragile. It could break.” The other boy runs to him and says, “Daddy! Daddy! Santa left me a pony, if only I can just find it!”

The story gets to the heart of Vaillant’s angle on the Grant Study. His central question is not how much or how little trouble these men met, but rather precisely how—and to what effect—they responded to that trouble. His main interpretive lens has been the psychoanalytic metaphor of “adaptations,” or unconscious responses to pain, conflict, or uncertainty.

and also:

Perhaps in this, I thought, lies the key to the good life—not rules to follow, nor problems to avoid, but an engaged humility, an earnest acceptance of life’s pains and promises.

Excerpts from The Atlantic.

[2026-02-01]: I just realized this wisdom is very similar to Stoicim’s “Amor fati”

List of English posts on Hossein Naghdbishi

The Courage to Be Disliked Summary

We are All Subjective Beings

Etiology vs Teleology

Apparent Cause and Effect

Life Is Not a Competition

Life-tasks

Courage and Worth

Happiness

Separation of Tasks, and Avoiding of Judgement

Community

Life is a Series of Dots

Misc

Summary of Man's Search for Meaning

Poor Man's VPN: How to Use Reverse SSH for Quick NAT Traversal

PWN Cheatsheet

x86_64 Assembly

Stack

Stack

Backgroud

Registers

Pointing to the code section

Pointing to the stack section

General Purpose Registers

Little Endian or Big Endian

Function Call in x86

Example C code

Binary Background Check

Return Oriented Programming

Finding ROPs

Misc

Memory Alignment

Sources

How to Share a Secret: Summary of Shamir's Paper

Tail Recursion

Further Reading

How to share Mullvad VPN from Android on all your network?

You Can Resolve Domains via curl Using DoH

So You Want to Learn Quicksort: Step-by-Step Guide to Basic, Lomuto & Hoare Partitioning.

Basic Partitioning

Lomuto’s Partitioning Algorithm

Hoare’s Partitioning Algorithm

Extra Tips

Conclusion

TODO

Dining Cryptographers

How to Convert Telegram Stickers to Signal

The Secret Interplay Between OpenSnitch and nftables

Hosting a Hugo Site Using Codeberg Pages with One-Click Deployment

Using Bash for Automatic Deployment

Make Capslock Great Again: XKB Customization for Sway

Buddhism

VPS Troubleshooting: A Quick Guide

Unable to connect to the server via SSH

Use the web console.

Are you connecting to the correct port and IP?

Is your sever up and running?

Use another server or computer for SSH connection

Use the verbose mode of SSH

Is your firewall allowing TCP packets to that port?

Is your SSH server configured well? Is it running?

High CPU usage

A one-shot or a chronic problem?

Find the CPU-consuming processes.

Kill, restart, or renice the processes

Case-by-case solutions

Updating everything

Unexpected reboot

How frequent are these reboots? and when do they happen?

Look through the logs

Check for common culprits

Ask for your VPS provider’s uptime

Slow response time / network connection instability

Do you have enough CPU/Disk/RAM resources?

Is your hard disk’s I/O speed okay?

Is your network okay?

Check for software issues

Summary

Hypothesis Testing, P-Value: Things We Learn From an Anime

How to Study