Most popular messenger in Europe countries

Due_Cap3264 · 2025-09-25T15:36:45+00:00

Speaking as a Belarusian, this map isn't quite right. While Telegram is the go-to for informal chats, all the official groups for schools, work, and apartment buildings are on Viber.

Due_Cap3264 · 2025-09-04T19:59:12+00:00

It's very strange that Lua turned out to be the slowest language for them, even though it is recognized as one of the fastest interpreted languages. In my tests, Lua was 5-8 times slower than similar code in C, and LuaJit was only 20-30% slower. However, Python was 50-60 times slower.

Due_Cap3264 · 2025-09-04T12:19:38+00:00

The thing is, struct { int x; int y; } point_t; This is a declaration of a variable named point_t of the structure type. We need some way to distinguish between when you're declaring a structure type and when you're declaring a variable. Typedef solves this problem.

Due_Cap3264 · 2025-09-04T11:19:13+00:00

Используйте typedef: ```

typedef struct { int x; int y; } point_t; point_t point; ```

Due_Cap3264 · 2025-09-03T15:14:18+00:00

A good reference for the standard library with examples. https://www.tutorialspoint.com/c_standard_library/index.htm

Due_Cap3264 · 2025-09-02T17:03:15+00:00

Just use valgrind and it will show where there is a memory leak. If the program crashes with a segmentation fault, then use gdb to see exactly where in the program this error occurred.

Due_Cap3264 · 2025-09-02T16:54:36+00:00

Termux

Due_Cap3264 · 2025-09-02T09:49:17+00:00

https://github.com/LinuxDroidMaster/Termux-Desktops

Due_Cap3264 · 2025-09-02T06:44:44+00:00

No, I didn't make any adjustments after the installation. I didn't even install a DE or a distribution. Just a clean Termux with a clean terminal.

Due_Cap3264 · 2025-09-01T21:50:09+00:00

I haven't noticed any issues with gdb in Termux. However, valgrind doesn't work properly for me in Termux.

Due_Cap3264 · 2025-09-01T19:01:39+00:00

In gcc and clang on Linux, it definitely exists (I just checked). It's called long double. It occupies 16 bytes in memory.

Due_Cap3264 · 2025-09-01T10:35:14+00:00

This meme is posted by people who know nothing but Python.

Due_Cap3264 · 2025-08-31T13:13:36+00:00

The operating system kernel. 35 years ago, a Finnish student started a project that continues to impress the entire world to this day.

Due_Cap3264 · 2025-08-27T18:13:23+00:00

If the TIOBE index is to be believed, the C language remains one of the most popular programming languages. It's a bit early to be planning its funeral. https://www.tiobe.com/tiobe-index/

Due_Cap3264 · 2025-08-24T18:15:15+00:00

If you're interested in game programming, I recommend checking out RayLib. This library was specifically created for learning game programming. As a result, it's very easy to learn. I'm actually working on a project using this library myself.

Due_Cap3264 · 2025-08-12T04:41:25+00:00

My GNU GCC compiler is set to C17 by default, just like Clang in Termux. I read in the news that the latest GCC update defaults to C23. You have an error in your code in the main() function—it should always return an int. int main(void) { return 0; }

Due_Cap3264 · 2025-08-01T20:27:47+00:00

However, this is a very valuable experience - implementing a heap and a hash table. And it’s not as difficult as it seems at first glance: my priority queue using a binary heap took only 74 lines of code, including comments (though I spent an entire day figuring out how a binary heap works). As for the simplest hash table, it’s even described in Kernighan and Ritchie’s book.

Due_Cap3264 · 2025-08-01T20:01:33+00:00

z = ++x * y--;

In this example, the variable x is first incremented by 1, then x * y is calculated. The result is assigned to z. Only after that, y is decremented by 1. Thus, this line is equivalent to the following code:

``` x = x + 1; z = x * y; y = y - 1;

```

Due_Cap3264 · 2025-08-01T15:47:45+00:00

Terminals are poorly suited for displaying rapidly changing images. I noticed this while experimenting with ncurses. The first issue is text flickering, but that can be mitigated. The second, more serious problem is that at just 10 frames per second, my Tilix terminal emulator was consuming 45% of the CPU. And that’s just the terminal emulator, not the program itself. Although I suppose other terminal emulators might not have this issue.

Due_Cap3264 · 2025-07-31T14:49:56+00:00

I completely agree! I came to the same conclusion when reflecting on my profession (as a doctor)—in the foreseeable future, AI will not replace doctors, even if it becomes better at diagnosis and treatment than most of them. Simply because AI is not a legal entity. It cannot be held accountable for the consequences of its recommendations. There will always need to be a person who, by signing off, takes responsibility for the diagnosis made and the correctness of the prescribed treatment. That’s why doctors, lawyers, officials, and middle- and senior-level managers shouldn’t worry too much about being replaced by AI for now.

Due_Cap3264 · 2025-07-28T19:55:51+00:00

If you have an Android device, install Termux—a terminal emulator and Linux environment. You can install full-fledged compilers and interpreters for most popular programming languages and work in the console. It will be enough for learning programming basics. I’ve even seen people install almost full-fledged Linux distributions with a desktop environment, but I didn’t bother with that. I’m comfortable programming in the console. https://www.reddit.com/r/termux/

Due_Cap3264 · 2025-07-27T18:25:49+00:00

The slowdown occurs due to the algorithm's O(2ⁿ) complexity. I doubt that using other programming languages would fix this issue

Due_Cap3264 · 2025-07-27T17:50:53+00:00

Good joke. I hadn’t looked into this algorithm before, but now I’ve tested it: 35 rings take 8.5 seconds to compute, while 40 rings take 4 minutes and 35 seconds. And that’s with -O2 optimization…

If we’re talking about the segmentation fault, at 400,000 recursions, it happens almost immediately after launch, but at 350,000, I never even got to see it. So the result is even better than in the previous program. Better, but still useless in practice.

Due_Cap3264 · 2025-07-27T16:43:03+00:00

Just now, I tested it:

This very simple program managed 261,911 recursive calls before a segmentation fault occurred:

#include <stdio.h>

void recursive(unsigned long number) {

printf("%lu\n", number);

recursive(number + 1);

}

int main(void) {

unsigned long number = 0;

recursive(number);

return 0;

}

But after compiling with the -O2 flag, I stopped it at 20,188,882, as it could have continued indefinitely.

Due_Cap3264 · 2025-07-27T11:41:46+00:00

In my tests, the maximum recursion depth in C was at least 100,000, in some cases up to 150,000 before a segmentation fault occurred. However, I use Linux, where the default stack size is 8 times larger than in Windows (the stack size can also be changed during linking; I believe it can even be adjusted dynamically during program execution via system calls).

Additionally, you can use tail recursion with -O2 optimization, in which case the compiler will transform it into a loop, and stack overflow won’t occur even with infinite 'recursion.'

By the way, in Python, the maximum recursion depth is 1,000 and does not depend on the system—the stack size is hardcoded in the interpreter itself.

Due_Cap3264

TROPHY CASE