DEV Community: Ahmed Abouzied

On the internet conquest of happiness

Ahmed Abouzied — Mon, 03 Jan 2022 01:46:13 +0000

You outgrow your town

Sympathetic surroundings are essential to happiness. I think it’s common enough to find oneself in a situation of recalling the song “Creep” by Radiohead and to be specific the part “What the hell am I doing here?". I dare say that you -the reader- share the experience with me of finding no one to share the interest in a specific subject you deeply care about. You find the people and the environment surrounding you to be not just ignorant about that subject, but also discouraging. A young person who wishes to read a serious book is discouraged by their parents. Teachers tell them off in the fear that these books may disorient their thoughts. And let’s not ignore the mere reason that this fear for the young person from such book induced by the parent, teacher or even friends is due to the mere fact that they have never read such books and they have neither the interest nor the will to read such books. They find that the young person’s interest in such books or topics peculiar and not useful. The young person then, of course, will themself lonesome and unhappy. For they seek to meet others with similar interests.

This is often the case for individuals with intellectual and artistic interests alike. This is actually the reason brilliant students who were born in small towns often apply for universities that are far away, for the subjects they wish to study are not offered by the nearby small universities. These students often move to larger cities where they can find better more specialized education offered by people who share the same interest in these subjects and arts.

They often find in universities other individuals who seek to learn the same subjects. This sparks enjoyable and fruitful conversations. These conversations embark a great deal of happiness. They share internal jokes. They agree and also disagree on opinions. They share and compare sources of knowledge. These experiences would have been impossible in their original environment of the small town.

If one is lucky then after university, one can find a job in the same field. In such a job one should meet other individuals who share the same interests and the same enjoyable experiences should continue. Such jobs, of course, will hardly be found in the small town they were born in. The more specialized the fields of interest are, the more these jobs lean to be located only in big cities with immense communities and specialized fields of trades.

These individuals clearly outgrow their hometowns They clearly grow at a rate that is faster than the rate of the small towns they were born in. Other individuals however find no reason to be unhappy in their small towns. Why would they, if all they seek is to be found near enough. The professions they seek do exist in that small town. All the knowledge they wish to acquire can be well acquired in the nearby schools and libraries. They hardly feel lonely due to the lack of people with similar interests because they can find a reasonable number of people who share the same interests as they do. Those people are said to live within the boundaries of their hometowns

Some individuals on the other hand, as explained by Bertrand Russel in his book “The conquest of happiness” Chapter IX, don’t have the means to move to big cities. For various reasons, they can’t move to attend a university far away from home. They can’t seek a job in the big city where they can meet individuals with similar artistic or intellectual interests. They know from books and papers that there are opportunities out there in the faraway big cities that suit their intellectual abilities, yet they find themselves incapable of seeking such opportunities due to various factors. Thus they remain unhappy and lonesome. Russel mentions that something needs to be done to help such individuals. Of course, Russel having died in 1970, hasn’t witnessed the effects of the internet and the opportunities it offers as a resolution for this dilemma.

The wonders of the internet

We now of course have the privilege of the internet. A place where a young person with an interest in a subject that is not being taught in the nearby school is able to search for information in that subject online. An artist is able to follow other artists on social media platforms and scroll through the pages and pages of artwork that would never be found in the nearby art galleries.

The internet has made it even possible to work entirely remotely from the comfort of your home for employers that reside in those big cities which you can not move to.

On the internet, one can find communities specialized in any subject that comes to mind. One can satisfy curiosity regarding any subject and have those meaningful conversations one misses in the small towns. It’s even international. One can seek specialized fields of knowledge that only reside across the borders in different countries with ease.

The ugly side

The ugly side of the equation is that even though those specialized communities exist, one still feels lonesome. Despite being able to read through those Reddit threads discussing watches which is a recent obsession of mine, I still have the need to talk to someone about watches. I don’t understand why. Isn’t it enough that I’ve found those individuals and all this information that I would have never found in the local library of the small town I live in?

Don’t get me wrong. I’m still grateful for the opportunity to have an internet access. Despite the hardships of remote work, I’m grateful for the opportunity to work with an international company from the comfort of my own home. I’m happy about the fact that I can meet those interesting people from all over the world through the internet. Despite the ugliness and the nonmagical experience of browsing through the kindle store for a book to read, I’m still grateful for the mere fact that I can browse and read those books which I could have never been able to read in the local libraries or bookshops. Nonetheless, something is missing.

On being active

I’m starting to think that the reason that I find the web to become recently tedious and boring is the fact that I’m hardly active. I don’t post on social media. I don’t share stories or articles. I hardly connect with people on Reddit, Twitter, or Goodreads. I only resort to scrolling and reading through the various things I find only without reacting, commenting, or posting something in return. I passively watch videos on youtube for hours without any action taken on my part. I came to realize that this is not a proper way of communication. I’m being passive. I’m using the internet as a method of communication to the proper extent. I’m only being on the receiving end of information. To phrase it as Russel has done, I know through the internet that people with similar interests do exist in some other places, but I can not converse or indulge in conversations with them. As it was the case of that individual who lived in the small town he grew up in and found an interest through the available books that is not shared with any near person.

As a matter of fact, the internet has far more resources on any topic than a library in a small town could ever have. So with the wider access to information that the internet makes me capable of, and with me being passive and only consuming resources found online without getting involved in online communities. I’m far worse. As I’ve far outgrown my town in the subjects I care about than I could possibly have with no internet access.

On C++ Memory Management

Ahmed Abouzied — Mon, 30 Mar 2020 02:15:29 +0000

Overview

Due to it's being type unsafe, it's very difficult to develop a garbage collector for c++. It's rather something that the C++ community often boosts about. It's true that it makes the compiled programs very lean and smaller in size. However, it adds work to the development process. You'd have to handle the memory yourself as a c++ developer.

Types of memory

There are mainly three types of memory that can be used by the developer :

Global Memory.
Stack Memory.
Heap Memory.

Global memory is allocated by the operating system loader. It exists in two different locations: .bss (uninitialized memory) and .data (value initialized memory).

These are the global variables declared outside of function scopes in c++. The following example is from the great book "Hands-On System Programming With C++"

#include <iostream>

int bss_mem = 0;
int data_mem = 42;

int main()
{
    std::cout << bss_mem << '\n';  // ==> 0
    std::cout << data_mem << '\n'; // ==> 42
}

Global memory specially value-initialized memory increases the size of the program on disk, therefore longer loading time.

Stack memory stores values in the order they are declared and these values are removed in the opposite order. Applying "last in first out" such as regular stack data structures. Thus all data stored on the stack must have known, fixed size.

When a function is called, it's pushed to the memory stack. All variables declared in that function are pushed to the stack right after the function one after the other. When that function returns, items are popped out of the stack one after the other until the function is popped. This is basically how the function scope is implemented.

Heap memory stores data with a size that might change. The heap is less organized. When data is put on the heap, the program requests a certain amount of space from the operating system. The operating system responds with an empty spot on the stack that is big enough, marks it as being in use and returns a pointer. Accessing data in the heap is usually slower than accessing the stack because you'd have to follow a pointer which means that you're jumping around in memory.

The process is described with very decent analogy on the rust-lang documentation website as follows :

Think of being seated at a restaurant. When you enter, you state the number of people in your group, and the staff finds an empty table that fits everyone and leads you there. If someone in your group comes late, they can ask where you’ve been seated to find you.

consider a server at a restaurant taking orders from many tables. It’s most efficient to get all the orders at one table before moving on to the next table. Taking an order from table A, then an order from table B, then one from A again, and then one from B again would be a much slower process.

Heap Allocation & Deallocation

Managing heap memory in c++ is through the new() and delete() operator functions as follows :

#include <iostream>
int main()
{
    auto ptr = new int(42); // allocating the variable on the heap and returning a pointer.
    std::cout << *ptr << '\n'; // ==> 42
    delete ptr; // releasing the memory.
}

This technique results in possible errors such as forgetting to call delete() to release the memory or calling delete() instead of delete [] when de-allocating an array.

Ownership

In C++11 the concept of pointer ownership was introduced to make it easier and less error-prone to manage the heap memory. The following two classes were introduced to achieve this :

std::unique_ptr{} : A pointer uniquely owned by a single entity.
This pointer is automatically deallocated by the compiler when it gets out of scope. Copying this pointer is not allowed.
std::shared_ptr{}: A pointer that may be owned by more than one entity. This pointer is deallocated automatically when all owners have released ownership of it. Copying this pointer is allowed.

It's discouraged by the C++ guidelines to perform any dynamic memory allocations by other than those two classes. Thus std::unique_ptr{} should be used instead of new() and delete(). To prevent memory leaks.

The previous example should be changed to be the following :

#include <memory>
#include <iostream>

int main()
{
    auto ptr = std::make_unique<int>(42);
    std::cout << *ptr << '\n'; // ==> 42
}

The following functions can be used to create unique and shared pointers :

std::make_unique<type>(args) to create std::unique_ptr{} that allocates and deallocates a single object.

std::make_unique<type[]>(size) to create std::unique_ptr{} that performs array allocation and deallocations.

std::make_shared() to create std::shared_ptr{}.

The Unique Pointer Class

It should be noted that std::unique_ptr{} accepts a pointer previously allocated by new() and on destruction, releases the memory it was given via delete.

The unique pointer can release it's allocation back to the heap on demand by calling the reset() function upon it. It explicitly tells the pointer to release its memory on demand without having to lose scope. It's demonstrated in the following example :

#include <memory>
#include <iostream>
int main()
{
    auto ptr = std::make_unique<int>();
    std::cout << ptr.get() << '\n'; // ==> 0x55bcfa2b1e70
    ptr.reset();
    std::cout << ptr.get() << '\n'; // ==> 0 (null pointer)
    if(ptr){ // the boolean operator is used to check if the pointer is null
        std::cout << *ptr << '\n';
    }
}

The Shared Pointer Class

Consider that you have two threads T1, T2. T1 creates a pointer and thus owns it. T2 has to use that pointer from T1 and thus owns it as much as T1.

Handling this with new() and delete() can be quite messy since it's difficult to predict if the other thread is no longer using the pointer and therefore difficult to determine when to release the memory and from which thread this should be done.

The std::shared_pt{} solves this problem with ease as in the following example.

#include <thread>
#include <iostream>
#include <memory>

class myclass
{
    int m_data{0};
public:
    ~myclass()
    {
        std::cout << "myclass deleted\n";
    }
    void inc()
    {
        m_data++;
    }
};

std::thread t1;
std::thread t2;

void thread2(const std::shared_ptr<myclass> ptr)
{
    for (auto i = 0; i < 100000;i++){
        ptr->inc();
    }
    std::cout << "thread2: complete\n";
}

void thread1()
{
    auto ptr = std::make_shared<myclass>();
    t2 = std::thread(thread2,ptr);

    for (auto i = 0; i < 10; i++){
        ptr->inc();
    }
    std::cout << "thread1 : complete\n";
}

int main()
{
    t1 = std::thread(thread1);
    t2.join();
    t2.join();
}
// > g++ -std=c++17 -lpthread main.cpp; ./a.out
// thread1: complete
// thread2: complete
// myclass deleted