#ITLife

Я всю осознанную часть жизнь считал себя программистом и как любой программист в девятом классе и на первом курсе я боялся двух вещей: публичных выступлений и симпатичных девушек.

Ничего не изменилось

const app = require ('.src/app')
app.start()

npm run build
— Creating an optimised production build...

Fatal to complete

Error: Cannot read property 'value' of undefined

А где???

#live

Думал сделать пост про nodejs, но передумал и решил рассказать про вот что:

Если вы хотите стать качественным it специалистом, то вам реально надо будет ебашить.
В качестве примера приведу себя:
На первом курсе я понимал примерно... Нихуя. В мозгу была устойка что 'ыыыы колледж научит, пуньк-среньк'. Но вот курс закончился а я научился только проперживать стулья в кабинете.

За лето 2023 года случилось достаточно событий которые дали мне понять что устойка оказалась говном и с ноября я начал погружаться в it. И знаете что понял? Система образования настолько отсасывает от самостоятельного обучения что это словами не передать.

С марта 2024 года пошли первые плоды моих страданий: стало намного легче воспринимать материал, который давали преподаватели.

С июля-августа я перешел на Linux и начал загружать себя проектами (на данный момент их 6 штук)

Вообщем вывод — вкатиться в it может и собака если ей правильно объяснить материал, а вот чтобы стать реальным спецом то готовьте своё очко к разрыву жопы от syntax error и экрану смерти

#JavaScript #Programming

NodeJS: хватит нас мучить!

Друзья, я больше не могу это терпеть! Пришло время сорвать все покровы, как говорится, сделать максимальный экспоуз. Как вам наверное известно, я последний год писал backend на NodeJS. Но, мать его, настал момент сказать всё как есть, чтоб больше ни у кого иллюзий не оставалось. NodeJS — место у параши, и его единственная задача — быть вспомогательной площадкой для фронтендщиков, а не для серьезного продакшна. Этот "движок" хорош только для того, чтобы, запускать Webpack и греть место на серверах!

Теперь внимание: погуглите компании, которые понаставили себе NodeJS в продакшн. И что мы видим? Смотрим их финансы и видим — чистой прибыли кот наплакал, а то и вообще в минусе сидят! А знаете, почему? Потому что все бабки уходят на покупку и обслуживание серверов, которые эту скотину тянут. По сути, они сами себя банкротят, запрыгнув в хайп-трейн на NodeJS. Печально, братцы.

И что дальше? А дальше, как обычно: приходит Майкрософт, покупает всех этих уставших, переписывает на C#, и всё, бай-бай, NodeJS. И это я вам не просто так говорю — инсайд от одного сверхчеловека. А что сам автор Node? Он свалил, как только сделал своё дело, и понял, что это уже не его проблема. Да и вообще, его "революционная" идея про асинхронность — никакой не прорыв. Уже к концу века у нас любая помойка будет работать быстрее, чем Node. Посмотрите на результаты Dotnet Core 8. Грустно, не правда ли?

Но проблема не только в этом. Один Express чего стоит. Фреймворк, мать его, топчется на месте, последний стабильный релиз был аж в мае 2019-го. Пытаются держать поддержку версий 2013-го года, да только без толку. Каждый раз, когда ты начинаешь новый проект на Express, тебе ещё и поддержку сайтов подгонять нужно. А про всякие Skoda или Adonis вообще молчу — туфта на постном масле, ни производительности, ни стабильности.

И вишенка на торте: если у вас вдруг приложение решит крашнуться, Node просто красиво ляжет, как и положено королю. Ведь это не баги, это "особенности платформы", говорят. Как по мне, так пусть они свои "особенности" в жопу засунут, а не мне в продакшн.

А ещё ведь JavaScript! Десятки идиотских паттернов, каждая команда пишет по-своему, куча своих стандартов. В итоге сидишь, разбираешь этот хаос, чтобы хоть понять, где у них тут что связано. Зато поджигают глаза, кодят как могут, лишь бы заработать пару секунд производительности. Вот уж спасибо, а я лучше без этого поживу.

Короче, друзья, если вам дорога ваша психика — подумайте дважды, прежде чем лезть в это болото под названием NodeJS.

#Education #OOP

Когда-то давно я говорил что сделаю гайд по ООП, так вот, этот день настал.

Про подходы написания кода я говорил вот в этом посте, поэтому почитайте сначала его, а потом уже этот.

Начнем:
1. Инкапсуляция

Это одна из самых хреново воспринимаемых парадигм ООП, так как у нее есть две основные трактовки.

## Инкапсуляция - объединение данных и функций которые управляют этими методами в единый компонент.

## Инкапсуляция - механизм языка, позволяющий ограничить доступ одних компонентов программы к другим.

А вот вам примерчик на C#:

class Phone {
   private string phone = " 7 555 555 55 55";

   public void ShowPhone()

   Console.WriteLine(this.phone)
}

Он соответствует как первой трактовке, так и второй... Ведь трактовки друг другу не противоречат!

При инкапсуляции происходит и объединение данных и функций, и в некоторых случаях позволяют ограничить доступ одних компонентов программы к другим

Почему в некоторых случаях? Потому что некоторые языки предоставляют механизм рефлексии, из-за чего можно вторгнуться в private поля и классы.

Но тут очень важный сука момент: инкапсуляция не является сокрытием, а то один человек яростно доказывал что: "Инкапсуляция обеспечивает сокрытие, но не является сокрытием"
Я могу обеспечить харчок в лицо хейтору, означает ли это что я харчок??

И если кто-то блять напишет что инкапсуляция это сокрытие то срочно звоните Илону Маску так как на моей жепной тяге он сможет добраться быстрее, чем на новейшем ракетоносителе.

Итоговое определение:

Инкапсуляция - объединение данных и функций которые управляют этими данными в единый компонент, а также ограничивающий доступ одних компонентов программы к другим

#Education #OOP

Переходим к следующему: Наследование

Тут с трактовками будет полегче, наверное

Наследование — механизм языка, позволяющий описывать новый класс на основе существующего

На C# это выглядит как-то так:

class A
{
   public void ShowMessage() // метод родителя
   {
       Console.WriteLine("message");
   }
}

class B : A {   } // наследуемся

class Program
{
   static void Main()
   {
       B b = new B(); // создаем экземпляр наследника
       b.ShowMessage(); // вызываем унаследованный метод
   }
}

Но на самом деле эта парадигма тоже проблемная, ведь все считают нужным впихнуть в определение что наследование обеспечивает повторное использование кода (чтобы заново методы в другом классе не писать, а обмазаться наследованием и все типо круто)

Но по факту наследование нужно только для того чтобы формировать иерархии родственных объектов и открывать дорожку к полиморфизму. Само по себе оно нахрен не нужно так как является причиной высокой связанности кода.

Если сказать проще то у вас может появиться родительский класс у которого 3000 наследников и вам уже будет страшно вносить изменения в этот класс, так как это может неприятно повлиять на наследников: причем не только на классы-наследники, но и на ваших персональных; ведь если вы такое находите, то коллеги с радостью вырвут с корнем ваш репродуктивный орган.

Изначально наследование должно быть только в динамических языках программирования, где наследуется конкретно сформированный объект, а не класс (как в JavaScript), но получилось иначе.

#Education #OOP

Следующее — Полиморфизм

А вот тут сейчас будет вообще жеподробительно, потому что Полиморфизм считается главной фишкой действительного ООП и второстепенной фичей желаемого ООП. Тут одним определением не отделаться, так как разные языки понимают разные формы полиморфизма, например в C#:
1. Ad-Hoc полиморфизм (в народе полиморфизм говна); представлен перегрузкой методов

class A
{
    public void ShowMessage() // Сам метод
    {
        Console.WriteLine("message");
    }

    public void ShowMessage(string message) // перегрузка метода
    {
        Console.WriteLine(message);
    }
}

class Program
{
    static void Main(string[] args)
    {
        A a = new A();
        a.ShowMessage(); // Выведет "message"
        a.ShowMessage("another message"); // Выведет "another message"
    }
}

2. Параметрический полиморфизм; представлен в C# generic'ами

public class Box<T> // Класс Box использует дженерик тип T
{
    private T item;
    public void SetItem(T item) // Установка значения элемента
    {
        item = item;
    }
    public T GetItem() // Получение значения элемента
    {
        return item;
    }
}
public class Program
{
    public static void Main()
    {
        // Создаем объект Box для хранения целочисленных значений
        Box<int> intBox = new Box<int>();
        intBox.SetItem(5);  // Устанавливаем значение 5 в коробку
        Console.WriteLine(intBox.GetItem());  // Получаем и выводим значение из коробки (5)

        // Создаем объект Box для хранения строковых значений
        Box<string> strBox = new Box<string>();
        strBox.SetItem("Hello, World!");  // Устанавливаем строку в коробку
        Console.WriteLine(strBox.GetItem());  // Получаем и выводим строку из коробки ("Hello, World!")
    }
}

3. Полиморфизм подтипов, который достигается с помощью механизмов наследования и upcast'ов

class A // Родитель
{
    public virtual void ShowMessage() // Виртуальный метод
    {
        Console.WriteLine("message");
    }
}

class B : A // Наследуемся
{
    public override void ShowMessage() // Переопределяем виртуальный метод
    {
        Console.WriteLine("override message");
    }
}

class Program
{
    static void Main(string[] args)
    {
        A a = new A();
        A b = new A(); // Приводим тип B к родительскому типу A (апкаст)
        a.ShowMessage(); // Выведет "message"
        b.ShowMessage(); // Выведет "override message"
    }
}

Вот последний тип нас и интересует, так как когда говорят о полиморфизме имеется ввиду именно эта реализация. В статических языках без полиморфизма в текущем виде наше ООП бы и закончилось, разве что могли бы код по модулям распихивать и всё. Но умные дяди спасли ситуацию и с помощью переопределения и upcast'ов мы можем выполнять различные действия. Звучит страшно но вот еще пример на C# как выглядит, к примеру, реализация логирования:

abstract class Logger // Родитель
{
    public abstract void Log(string text);
}

class ConsoleLogger : Logger // Консольный логгер
{
    public override void Log(string text)
    {
        Console.WriteLine(text);
    }
}

class FileLogger : Logger // Файловый логгер
{
    public override void Log(string text)
    {
        File.WriteAllText("log.txt", text);
    }
}

class HttpLogger : Logger // http логгер
{
    public override void Log(string text)
    {
        new HttpClient().GetAsync("https://example.com?log=" + text);
    }
}

В ходе выполнения данной программы пользователь сам решает, какая из реализаций ему нужна: просто выводить в консоль лог, сохранять его в файл log.txt или идти в глубины Интернета.

#Education #OOP

Но это всё в статической типизации. А в динамической мы можем прямо в RunTime заменять методы в объектах непринуждённым способом:

const plus = (a, b) => {
    return a + b
}

plus(5, 5) // 10
plus("рот ", "топтал") // рот топтал

Такой код в JS тоже считается применением параметрического полиморфизма. При динамической типизации полиморфизм настолько естественен, что мы юзаем его не задумываясь и это при том что с языками со статической типизацией проще у самого себя отсосать чем разобраться с полиморфизмом

Раз уж у нас такая пьянка, то давайте я вам покажу одну интересную фичу:

class Parrent // Родитель
{
    public virtual void Test2()
    {
        Console.WriteLine("parent test2 method");
    }
}

class A : Parrent
{
    public void Test()
    {
        Console.WriteLine("test method");
    }

    public override void Test2()
    {
        this.Test();
    }
}

class Program
{
    static void Main(string[] args)
    {
        Parrent obj = new A(); // Апкаст
        obj.Test2(); // Выведет: "test method"
        obj.Test(); // Даже не скомпилируется, хотя метод public
    }
}

Как мы после апкаста сможем вызвать метод Test?? Никак! Неужели он пропал??
Не совсем, потому что он вызывается через метод Test2 . Неужели метод Test из public стал private ? Так и есть. Получается что? Что полиморфизм обеспечивает сокрытие, ничего вам не напоминает???

#Programming #Java #Kotlin

Kotlin должен УНИЧТОЖИТЬ Java

Java — это ёбаная помойка, которой место на свалке технологий. Это чертовски громоздкий, прожорливый и устаревший динозавр, который изжил себя ещё в эпоху кнопочных телефонов. А теперь, внимание, на сцене — Kotlin. Молодой, дерзкий и безжалостный убийца, который разорвёт Java на куски.

Почему Java — это боль

Java — это язык для тех, кто любит страдать. Посмотрите на этот ад из шаблонов и бюрократии:

public class Cat {
    private final String name;
    private final String color;
    private final Integer height;

    public Cat(String name, String color, Integer height) {
        this.name = name;
        this.color = color;
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public String getColor() {
        return color;
    }

    public Integer getHeight() {
        return height;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Cat cat = (Cat) o;
        return Objects.equals(name, cat.name) && Objects.equals(color, cat.color) && Objects.equals(height, cat.height);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, color, height);
    }
}

Да за что? За какой грех нужно писать столько говнокода? Сравните с Kotlin:

data class Cat(val name: String, val color: String, val height: Int)

Вот и всё. Вы понимаете? ВСЁ. В Kotlin меньше кода, меньше боли и больше времени на жизнь.

Kotlin: дыхание свежего воздуха

Kotlin — это как найти новый смысл жизни после лет страданий. Почему? Да потому что:
Меньше кода — больше кайфа. Зачем писать 100 строк дерьма, если можно решить ту же задачу одной? Java — это как писать письмо от руки, а Kotlin — как отправить мем в Telegram.

NullPointerException? Да иди нахуй. Kotlin рубит с плеча: или ты работаешь с null правильно, или проваливай. А Java? Да она обожает швырять NullPointerException тебе в лицо как тухлые яйца.

Синтаксис для людей. В Kotlin код читается как человеческий язык. В Java — как заклинание тёмной магии из дешёвого фэнтези.

Java: хватит уже мучить нас

Java — это как Windows Vista от мира языков программирования. Медленный, неудобный и постоянно отнимающий у вас последние нервы. Да, в 90-х это был прорыв, но сейчас? Это устаревший архаизм, который нужно просто отключить от аппарата искусственного дыхания.

И давайте честно: каждый раз, когда вы открываете Android Studio и она нагревает вашу комнату, хочется крикнуть: "СУКА, ДА ПОРА УЖЕ ЧТО-ТО ДЕЛАТЬ С ЭТОЙ ГРЕБАНОЙ JAVA!".

Kotlin: будущее уже здесь

Kotlin — это как утренний кофе после дикого похмелья от Java. Он удобный, быстрый и чёткий. Он заботится о вас, в то время как Java смотрит на ваши мучения и довольно ухмыляется.
Короче, пора заканчивать с этим Java-кодоблудием. Kotlin должен её похоронить и поставить сверху памятник с надписью "REST IN PAIN".

Переходите на Kotlin, живите проще, кайфуйте больше. А Java? Да пусть она валяется на свалке.

#ITLife

Говорят в IT хорошие зарплаты...
Давайте похвастаемся, кто что заработал. Я например:

1. Выгорание
2. Нестабильность
3. Депрессию
4. Боль в пояснице
5. Синдром самозванца
6. Перфекционизм

А вы?

(Разбор принципов ООП будет, не переживайте)

#Education #OOP

Абстракция

Один из ключевых принципов, который позволяет скрыть сложность системы, выделяя только необходимые детали. Давайте разберем этот принцип на примере, чтобы было понятнее.

Представьте, что у нас есть класс Vehicle (Транспортное средство), который определяет общие характеристики и поведение для всех транспортных средств. Мы можем создать несколько подклассов, таких как Car (Автомобиль) и Bicycle (Велосипед), которые будут наследовать от Vehicle и реализовывать свои специфические детали.

abstract class Vehicle // Абстрактный класс
{
    public abstract void Start(); // Абстрактный метод

    public void Stop() // Конкретный метод
    {
        Console.WriteLine("Vehicle stopped.");
    }
}

class Car : Vehicle
{
    public override void Start()
    {
        Console.WriteLine("Car started.");
    }
}

class Bicycle : Vehicle
{
    public override void Start()
    {
        Console.WriteLine("Bicycle started.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Vehicle myCar = new Car(); // Создаем объект Car
        myCar.Start(); // Выведет: "Car started."
        myCar.Stop(); // Выведет: "Vehicle stopped."

        Vehicle myBicycle = new Bicycle(); // Создаем объект Bicycle
        myBicycle.Start(); // Выведет: "Bicycle started."
        myBicycle.Stop(); // Выведет: "Vehicle stopped."
    }
}

В этом примере класс Vehicle является абстрактным, что означает, что мы не можем создать его экземпляр напрямую. Вместо этого мы определяем абстрактный метод Start(), который должен быть реализован в каждом подклассе. Это позволяет нам скрыть детали реализации и работать с объектами на более высоком уровне абстракции.

Теперь, когда мы создаем объекты Car и Bicycle, мы можем вызывать метод Start(), не заботясь о том, как именно он реализован в каждом конкретном классе. Это и есть сила абстракции: мы можем взаимодействовать с объектами через общий интерфейс, не вникая в детали их реализации.

Таким образом, абстракция помогает нам управлять сложностью, позволяя сосредоточиться на том, что действительно важно, и игнорировать ненужные детали. Это также способствует лучшей организации кода и его повторному использованию.

Так что, как видите, абстракция в ООП — это не просто теоретическая концепция, а мощный инструмент, который делает разработку более эффективной и понятной.

#Other

Чем я занимаюсь?
Системная архитектура, сети и безопасность. По этим делам я лучший в моем окружении.
Но кому это надо? Пока вы учили пестики с тычинками и пели песенки о любви я получал root права в базах данных "1С Форус", я был в одном клике от удаления языка '1С' как сущность.

Я ловлю межсайтовые скриптинги, мониторю DDoS атаки, откатываю ошибки в базах данных и ошибки в транзакциях.

Internet — слышали про такое? Каждую минуту передается петабайт данных и вы хоть представляете как это работает? Нолики и единички бегают чтобы вы могли порнушку посмотреть со своего телефона. Каждый салага исходит на говно если его dubstep ремикс качается больше 12 секунд и это не магия, а способность и тяжкий труд.

И такие как Я следят за тем чтобы пакеты были доставлены в целостности. Так чем я по итогу занимаюсь? Слежу за тем чтобы один кривой config в ключевом месте не разорил к ебеням всю контору. Вот блять чем я занимаюсь.

#ITLife

Синдром самозванца в программировании

Знакомо чувство, когда ты вроде бы что-то сделал, получил похвалу, но вместо гордости ловишь себя на мысли: "Это просто случайность, мне повезло, я не такой уж хороший разработчик"?

Я знаю какого это. Я нахожусь в весьма сложном положении и мне приходится совмещать учёбу, дорогу домой (по три часа в день туда-сюда), проекты (+ коммерческие), ответственность перед семьёй, и, кажется, целую вселенную задач. За последнее время я загрузил себя шестью проектами в надежде почувствовать себя увереннее. Вместо этого возникло ощущение будто я всё ещё недостаточно хорош, что я должен работать больше, быть умнее, сильнее.

Синдром самозванца бьёт по самым слабым точкам. Я часто думаю: "Почему другие легко справляются, а у меня это отнимает все силы?" Особенно больно, когда выгоревший, со всеми этими сомнениями, открываешь соцсети или просто идёшь по улице и видишь людей, которые выглядят счастливыми и уверенными.

Ещё больнее становится когда понимаешь, что часть твоих усилий направлена не на себя, а на попытки стать кем-то другим. Мне приходилось менять себя в надежде что так я стану "достойным". Я стал работать ещё усерднее, брал на себя больше, пытался быть для всех незаменимым, в том числе для людей, которые меня предали. Но это не приносило радости — только истощение и страх.

Что важно понять?

Синдром самозванца может казаться чем-то неизбежным. Кажется, что ты всегда будешь недостаточно хорош. Но это неправда. Давайте вспомним, что:

Программирование — это не про знание всего. Это про способность учиться, адаптироваться и искать решения. Никто не знает всё, но у каждого из нас есть свой стиль работы и свои сильные стороны.

Ваши усилия ценны. Даже если вам кажется, что вы просто "везунчик", это не так. Успех складывается из вашего труда, ваших знаний, ваших идей.

Ошибки и сложности — это не провал. Это часть пути. Сложности — это то, где вы растёте.

Да, я всё ещё учусь верить в себя. Иногда это тяжело. Но я понял: никто не обязан быть идеальным. Вы достойны своих успехов и того, чтобы двигаться вперёд.

Поддерживайте себя и других

Когда вы видите, что кто-то сомневается, подбодрите его. Когда сомневаетесь сами, напомните себе: вы не одиноки. Ваш путь уникален, и у каждого он идёт в своём темпе.
Лично мне помогают друзья/подруги и программирование. Даже несмотря на весь стресс, я стараюсь быть добрым к себе и к другим. Я знаю, как тяжело бывает поверить в себя, но важно не сдаваться. Мы все движемся вперёд, и даже маленький шаг — это прогресс.

Если вы читаете это, знайте: вы заслуживаете своих успехов. Не позволяйте сомнениям отнимать ваши силы. Ошибки — это уроки, а не приговор.

Программирование — это не только про код, но и про уверенность в себе. Мы растём не только как разработчики, но и как люди.

#Other #Project

Проект. Выжили. Ебть.


Интернет магазин с CMS — это полный разрыв мозга. И не потому, что он был какой-то невозможный, а потому что, блять, мы с напарницей вдвоем вытянули его на себе, пока остальные два человека из команды делали вид, что работают.

Точнее, даже вид особо не делали. Они тупо сидели, втыкая в мониторы (ладно-ладно, спасибо за покушать тут базара 0), а на защите получили свои «пятерочки», будто сделали что-то кроме теплого воздуха и шаурмы с пиццей.

Мы с ней ебашили на полную: и код, и дизайн, и хуева туча багов, которые пришлось чинить за всех. У вас бывало такое, что ты после пар не можешь отдышаться, но всё равно едешь домой, включаешь ноут и продолжаешь работать? Вот это было каждый ебаный день.

Процесс довели до конца. ЗАЩИТИЛИ!

Мы не просто представили проект — мы уничтожили защиту. Отвечали за всех, показывали всё, что можно. Ну и, конечно, радость смешалась с горечью, потому что по факту это наш проект, а лавры достались всем. Но хер с ними.

Если честно, этот проект не просто физически вымотал, он добил морально. Последние месяцы — это какой-то ебаный трэш: синдром самозванца, нервы, личные переживания, которые ещё эхом отдаются в голове. Были моменты, когда я тупо лежал в кровати, смотрел в потолок и думал: «Нахуя мне это всё вообще?»

Но знаете, что я понял? Мысли — это одно, а действия — это совсем другое. Ты можешь быть загнанным как собака, можешь сомневаться в себе, но если ты берешь и ешишь вперёд, то рано или поздно приходит результат.

Вывод:

Этот проект для меня — доказательство того, что ты можешь быть в аду, но если не сдаешься, выход всё равно найдешь. Мы затащили, мы сделали, мы смогли. И я горжусь этим.

Если вы сейчас в жопе и кажется, что все против вас — плевать на всё. Просто делайте. У меня получилось, и у вас обязательно тоже.

#Project

Я вам че, клоун что ли? Хорошо...

Ну-ка, давайте, объясните мне почему при втором вызове метода Say() у нашего алкаша происходит магическое исцеление:

 
public static class Program
{
    public static void Main() 
    { 
        Boozer boozer = new Boozer();
        boozer.Say();

        Human human = boozer;
        human.Say();
    } 
}

class Human()
{
    public void Say()
    {
        Console.WriteLine("Hello world");
    }
}

class Boozer : Human
{
    public new void Say()
    {
        Console.WriteLine("Suka Blyat");
    }

Кто даст внятное объяснение подарю звёздочку. Удачи

#OS

Windows, macOS или Linux — какой выбрать?

Давайте разбираться, что к чему. Начнем с Windows. Все мы с ней знакомы, не зря она почти у каждого второго. Первое знакомство с ПК — это, скорее всего, именно она. Помните, как вы теряли часы за Суперкоровой? Долгие года на этой системе, и все вроде как хорошо, пока не начинаешь её реально использовать, а не просто юзать для «игрушек» и сёрфа.

Но, господи, какие косяки! Сначала вот этот платный софт — винда стоит порядка 200 евро! Да, многие говорят, что они взяли её бесплатно, но, серьезно, как ты себе это объясняешь? Все эти кряки и активации через непонятные скрипты — это жесть, особенно если на твоем компе лежат важные данные. Вот прямо сейчас задумывайся, кому ты доверяешь свой ПК?

Закрытый исходный код — не могу понять, как нормальные люди могут с этим мириться. Ты вообще не знаешь, что на твоем компе творится! Все эти обновления, всплывающие окна, которые просто панику наводят, звучат на всю катушку. И даже если ты отключишь эти вещи, как найти нужную кнопку, чтобы отключить очередную дрянь, ты не знаешь! Вот так всё и работает — ты всегда полностью зависим от того, что тебе разрешает делать Microsoft.

А потом винда 11 — бомба! Обещали, что десятая версия будет последней. И вот, хоп, через пару лет появляется 11-я, которую тебе не поставить на старое железо. Причем, не забываем, что все это сделано искусственно! Дескать, мол, вот вам еще 30 баксов, и мы вам дадим ещё год обновлений для десятки. Окей, окей, ребята, клоуны в офисах.

Ну а интерфейс? Серьезно, ребят, с дизайном прям вообще слишком красиво? Не особо. Они тупо позабрали фишки у Apple и считают это успехом. Вспомнить хотя бы кучу багов и недоработок в 11 винде — это просто катастрофа. Каждый день ждешь, когда с ней что-то пойдет не так.

А про безопасность? Никогда не чувствуешь себя защищённым! Вирусы, трояны, всякая заразу легко пролезает в Windows, потому что никто не следит за тем, что происходит. Люди вообще не понимают элементарные вещи, как работают файлы и расширения. Даже простое изменение расширения файла — и хакеры могут запросто замаскировать вирус под картинку. Ну а сама ОС все это способствует.

macOS? Не лучше. По сути, это тот же закрытый код, просто у Apple всё красиво и работает почти без проблем. Но на самом деле это далеко не идеал. Если вы не купите дорогущие Apple-товары, то забудьте о macOS. Вот не поверите, но многие проблемы те же, что и в винде: не можешь кастомизировать, не можешь сделать систему под себя. Да, интерфейс красивый, да, работает хорошо, но не так гибко, как хотелось бы.

А теперь Linux — вот это уже другая тема. Это полностью открытый исходник, который разработан с идеей свободы. Никто не заставляет тебя ставить какой-то странный софт. Хочешь, получай — хочешь, не трогай! Плюс всякие дистрибутивы — ты можешь настроить систему под себя, выбрать всё, что хочешь, и не зависеть от кто-то чужих решений. Настройка — это уже не проблема, даже если ты новичок, процесс установки просто, как два пальца об асфальт. Лишь бы комп был не древним.

Уже почти 2025 год, а Linux по-прежнему остаётся самым гибким вариантом. Да, все эти внешние интерфейсы типа GNOME или KDE — они просто шикарны, но и LXQT для слабых машин — тоже норм, чё. Вообще, Linux-это удобно, и, по большому счёту, всё работает сразу. К тому же, если ты что-то накосячил — ты всегда можешь вернуться в систему и пофиксить, а с Windows — забудь.

Если ты не можешь выбрать между Linux и Windows, просто поставь Dual Boot — и наслаждайся обеими системами! Это будет круто и удобно, и ты не будешь бояться, что всё сломается, если ты используешь несколько систем.

В общем, выбор за вами — Windows для большинства игр и софта, macOS если не любишь геморрой, и Linux если хочешь полный контроль над своим ПК.

#Other

Как такового найма у меня не было. Под работай я имел ввиду фриланс и другие одноразовые задания.

А что касается начала программирования, то тут интересная история: я по жизни гуманитарий и пошел в программирование потому что "мама сказала". Первый год обучения был не тот что ужасным, а скорее проебанное время жизни.
Позже я начал самостоятельную изучать IT с нуля и понял что это незабываемые ощущения. Сейчас я до сих пор изучаю что-нибудь новое и кажется что мое обучение будет вечным.

Ха