#535_GO_LIB_TP

Какие библиотеки чаще всего используют для взаимодействия с PostgreSQL в проектах на Golang?


Для работы с базой данных PostgreSQL в Go-проектах наиболее часто используются следующие библиотеки:

database/sql + lib/pq — стандартный пакет Go (database/sql) совместно с драйвером lib/pq, который реализует интерфейс подключения к PostgreSQL.
Этот вариант подходит для большинства случаев, поскольку обеспечивает простоту интеграции и совместимость с различными базами данных.

import (
  "database/sql"
  _ "github.com/lib/pq"
)

sqlx — расширяет возможности стандартного пакета database/sql.
Она добавляет дополнительные удобные методы для сканирования результатов запросов и управления транзакциями.
Подходит для проектов, которым нужен простой доступ к данным и минимальное количество сторонних зависимостей.

import (
  "github.com/jmoiron/sqlx"
)

pgx — высокопроизводительная библиотека для работы с PostgreSQL, созданная специально для производительности и функциональности.
Позволяет эффективно управлять соединениями, поддерживает продвинутые SQL-функции и оптимизирует работу с большим объемом данных.

import (
  "github.com/jackc/pgx/v5"
)

gorm — ORM-библиотека для Go, поддерживающая различные базы данных, включая PostgreSQL.
gorm позволяет легко создавать модели, миграционные скрипты и автоматически синхронизироваться с таблицами. Удобна для больших приложений с частым изменением структуры данных.

import (
  "gorm.io/gorm"
  "gorm.io/driver/postgres"
)

Другие менее распространенные варианты:
ent — инструмент автоматического построения моделей и схем данных поверх PostgreSQL. Обеспечивает удобное управление структурами данных и связи между ними.
pop — легковесная ORM для работы с PostgreSQL, ориентированная на удобство и минимализм API.


Каждая из перечисленных библиотек имеет свои преимущества и области применения.
Выбор зависит от требований проекта: производительность, сложность схемы данных, простота реализации CRUD-операций и потребности в ORM-подходе.

#536_GO_LIB_TP

Пакет context в Golang, для чего он нужен и с чем его едят?

Пакет context в Go — стандартный пакет, используемый для передачи значений между API уровнями и отмены операций во всей цепочке вызовов функций.
Контекст предназначен для упрощения обработки состояний запросов и отмены длительных операций.


Для чего нужен контекст?

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

Вот такие ситуации решает пакет context в Golang!


Контекст — специальный инструмент, позволяющий передавать инструкции ("указания") от одной части программы к другой.
Представьте контекст как помощника-посредника, который передает важные сигналы другим частям кода.


Какие задачи решаются с помощью пакета context?

Передача сообщений — пусть, у нас запущено много разных процессов одновременно, каждый делает свою работу долго-долго. И вдруг главный процесс понял, что больше не нужны никакие вычисления!
Пакет context помогает передать сообщение "стоп" всем остальным процессам, чтобы они прекратили свою работу.

Пример: пользователь запустил программу, которая скачивает файлы из интернета.
Пользователь нажал кнопку "отмена загрузки" → программа мгновенно прекращает загрузку, даже если там сотни файлов.

Установка ограничений по времени — иногда важно ограничить длительность какого-то процесса.
Представим игру, где игроку дается ровно одна минута на выполнение задания. Через минуту игра автоматически останавливается независимо от того, успел игрок завершить задание или нет.

Пример: программа пытается подключиться к серверу базы данных.
Если соединение не устанавливается за 5 секунд, оно автоматически прерывается.

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

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


Основные интерфейсы и структуры:

Функции из пакета context:
Background() — начинающий контекст, от которого зависят остальные.
Это как основа, от которой начинают строиться новые контексты.
WithCancel() — создает новый контекст, который можно отменить принудительно в любое время.
То есть можно сказать нашему помощнику прекратить всё немедленно, как только потребуется.
WithTimeout() — используется для ограничения продолжительности задачи по времени.
Удобно, когда хочешь убедиться, что задача не продлится дольше определенного периода.
WithDeadline() — похож на предыдущий, но устанавливает точный срок окончания задачи, а не интервал ожидания.
WithValue() — позволяет прикреплять дополнительные данные к контексту.
Очень удобно, если хочешь хранить какую-нибудь важную информацию вроде имени пользователя или сессии, которую потом можно достать из любого места программы.


Тип Context — представляет собой абстрактный тип контекста, поддерживающий два ключевых свойства:
Отменяемость операции.
Передачу произвольных данных («метаданных») внутри приложения.

Контекст создается функциями типа

WithCancel()
WithTimeout()
WithDeadline().

Каждый новый контекст наследует поведение родительского контекста.

Пример базового использования:

ctx := context.Background()
ctx, cancel := context.WithTimeout(ctx, time.Second*5)
defer cancel()
// Выполнение длительной операции
result, err := longOperation(ctx)
if ctx.Err() != nil {
    fmt.Println("Операция отменена:", ctx.Err())
}

.

Функция Background() — возвращает пустой, незавершенный контекст, подходящий для корневых контекстов запросов.
Его нельзя отменить, и он не имеет дедлайна.

ctx := context.Background()

Function WithValue(parent Context, key interface{}, val interface{}) Context:

Создает производный контекст с дополнительным значением.
Это полезно для хранения уникальных данных о конкретном запросе, таких как токены авторизации или идентификаторы пользователей.

type userKey struct{}

ctx = context.WithValue(ctx, userKey{}, "alice")
value := ctx.Value(userKey{})
fmt.Println(value) // Выведет alice

Функции отмены:

WithCancel(parent Context) — cоздает дочерний контекст, который можно отменить отдельно от родителя. После вызова функции cancel(), связанный контекст получает ошибку отмены.

WithTimeout(parent Context, timeout time.Duration) — устанавливает таймаут для завершения всех действий над данным контекстом.

WithDeadline(parent Context, deadline time.Time) — устанавливает крайнюю точку времени, до которой должна завершаться операция.


Примеры создания временных контекстов:

ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
defer cancel()

ctx, cancel = context.WithDeadline(context.Background(), time.Now().Add(time.Hour))
defer cancel()

Метод Err() — возвращает ошибку, соответствующую состоянию контекста.

Возможные состояния:
Нет ошибок (если ничего не произошло),
Ошибка отмены,
Таймаут превышен.

select {
case <-ctx.Done():
    fmt.Println("Отмена или таймаут:", ctx.Err())
default:
    fmt.Println("Ожидание...")
}

Как правильно использовать?
— Всегда проверяйте состояние контекста перед началом длительной операции.
— Используйте дефер и отмену для своевременного освобождения ресурсов.
— Не передавайте один и тот же контекст нескольким параллельным операциям, создавая отдельный контекст для каждой.


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

#537_RUST_LIB_SDS

В Rust стандартная реализация хэш-таблицы называется HashMap, и она находится в модуле std::collections::HashMap.
HashMap — ассоциативный контейнер, который хранит пары «ключ — значение», где ключи уникальны и хэшируются для быстрого поиска.

Прежде чем использовать HashMap, его нужно импортировать:

 use std::collections::HashMap;
 

Создание пустой HashMap:

 let mut map: HashMap<&str, i32> = HashMap::new();
 

Инициализация с данными:

 use std::collections::HashMap;

let mut map = HashMap::from([
  ("один", 1),
  ("два", 2),
  ("три", 3),
]);
 

Для использования HashMap::from нужна версия Rust ≥ 1.56 (или включена соответствующая фича в более ранних версиях).

Или через вектор:

 let map: HashMap<_, _> = vec![("a", 1), ("b", 2), ("c", 3)].into_iter().collect();
 

Основные методы.

Вставка (insert):

 map.insert("четыре", 4);
 

Если ключ уже существует — старое значение заменяется, и возвращается предыдущее значение (опционально):

 let old_value = map.insert("один", 10); // old_value = Some(1)
 

Получение значения (get):

match map.get("два") {
  Some(&value) => println!("Значение: {}", value),
  None => println!("Ключ не найден"),
}

get возвращает Option<&V>, так как ключ может отсутствовать.

Удаление (remove):

let removed_value = map.remove("три"); // Option<i32>

Проверка наличия ключа (contains_key):

if map.contains_key("один") {
  println!("Ключ 'один' существует");
}

Обновление только если ключ отсутствует (entry API):

use std::collections::hash_map::Entry;

match map.entry("пять") {
  Entry::Occupied(_) => println!("Ключ уже существует"),
  Entry::Vacant(e) => {
    e.insert(5);
  }
}

Или короче:

map.entry("пять").or_insert(5);

Если нужно вычислить значение лениво:

map.entry("шесть").or_insert_with(|| 2 * 3);

Другие полезные методы

len() — возвращает количество пар «ключ-значение»;

is_empty() — проверяет, пуст ли HashMap;

clear() — удаляет все элементы;

iter() — возвращает итератор по парам (&K, &V);

iter_mut() — итератор с возможностью изменения значений;

keys() — итератор по ключам;

values() — итератор по значениям;

values_mut() — итератор по изменяемым значениям;

Пример итерации:

for (key, value) in &map {
  println!("{}: {}", key, value);
}

Ограничения на типы.

Ключи в HashMap должны реализовывать трейты:
Hash — для вычисления хэш-кода;
Eq — для сравнения на равенство.

Примеры допустимых типов ключей:

String, &str, i32, (i32, i32), пользовательские структуры (если реализованы Hash + Eq). 

Пример пользовательского ключа:

#[derive(Hash, Eq, PartialEq, Debug)]
struct Person {
  id: u32,
  name: String,
}

let mut people = HashMap::new();
people.insert(Person { id: 1, name: "Алиса".to_string() }, "инженер");

.

Владение и заимствование.

— при вставке String — владение передаётся в HashMap.
— при вставке &str — нужно, чтобы строка жила дольше HashMap.

Пример с владением:

let mut map = HashMap::new();
map.insert(String::from("ключ"), 42); // String передаётся по значению
 

Пример: подсчёт частоты слов:

use std::collections::HashMap;

let text = "rust is great and rust is fast";
let mut word_count = HashMap::new();

for word in text.split_whitespace() {
  *word_count.entry(word.to_lowercase()).or_insert(0) += 1;
}

for (word, count) in &word_count {
  println!("{}: {}", word, count);
}

Вывод:

rust: 2
is: 2
great: 1
and: 1
fast: 1

Производительность.
— Вставка, поиск, удаление — в среднем O(1).
— Худший случай — O(n) при коллизиях, но маловероятен при хорошей хэш-функции.
По умолчанию используется хэш-функция SipHash, безопасная от DoS-атак.


Можно заменить хэшер (например, на ahash или fxhash) для повышения скорости:

 # Cargo.toml
[dependencies]
ahash = "0.8"

use ahash::AHasher;
use std::hash::BuildHasherDefault;

type FastMap<K, V> = HashMap<K, V, BuildHasherDefault<AHasher>>;

let mut map: FastMap<&str, i32> = HashMap::default();

Резюме:
HashMap — основной способ хранения ассоциативных данных в Rust.
Требует Hash + Eq от ключей.
Безопасен благодаря системе владения и проверкам на этапе компиляции.
Богатый API: entry, итераторы, вставка/поиск/удаление и т.д.
Гибок: можно кастомизировать хэш-функцию.


Замечания:
Если нужно упорядоченное хранение — смотри в сторону BTreeMap.
Если нужен мульти-ключ или дублирующиеся ключи — hashbrown или другие сторонние решения.

#538_Cpp_LIB_SDS_STL

Что делает std::cin.tie(NULL); в C++?

Операция std::cin.tie(NULL) — отменяет привязку (tie) потока ввода (std::cin) к потоку вывода (std::cout).


Суть привязки потоков (tie).
Потоки ввода и вывода связаны между собой по умолчанию в C++.
Это означает, что всякий раз, когда производится операция вывода (например, std::cout << something;), система синхронизирует потоки ввода и вывода, гарантируя, что ввод и вывод происходят синхронно.
То есть перед выполнением следующего шага чтения (std::cin) операционная система гарантирует, что предыдущий вывод (std::cout) завершён.

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


Зачем разрывать связь (tie(NULL))?

Повышение производительности — синхронизация между потоками увеличивает накладные расходы.
Если приложение не нуждается в гарантии синхронизации (например, серверные приложения или программы с большими вычислительными нагрузками), разрыв связи между потоками может заметно ускорить работу программы.

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


Пример использования:
Допустим, есть следующая программа:

#include <iostream>

int main() {
  std::cin.tie(NULL); // Отменяем привязку cin к cout

  std::cout << "Enter your name: ";
  std::string name;
  std::cin >> name;

  std::cout << "Hello, " << name << "!\n";
  return 0;
}

До вызова std::cin.tie(NULL) вывод на экран происходил синхронно с вводом, то есть строка приглашения выводилась только после завершения предыдущего ввода.
После разрыва связи вывод немедленно появляется на экране, не дожидаясь завершения последующих операций ввода.


Важно помнить:
Разрыв связи между потоками может повлиять на визуальное представление приложений, работающих в режиме реального времени.
Будьте осторожны при применении этого трюка в ситуациях, где необходим аккуратный контроль взаимодействия с пользователем.

#539_Cpp_PY_LIB_SDS_STL_IdPt

Как в С++, организовать конструкцию подобную switch в Go или match в Rust и Python, которая позволит в качестве меток case использовать не только целочисленные и символьные значения?

Интересный не очень очевидный прием, в нем нет ничего очень умного или хитрого, но таким образом можно заменить конструкцию switch в С++ и при этом мы сможем оперировать не только целочисленными типами, но и строками выражениями и другими объектами (подобная же конструкция с использованием словаря вместо std::map в С++, способна заменить конструкцию math (конструкции switch или подобной ей в Python не было вплоть до версии 3.10)).

Давайте создадим простейший калькулятор:

#include <iostream>
#include <map>
#include <cmath>

int main() {
    auto opd1 = 0., opd2 = 0.;
    char operation = '\0';
    std::cin >> opd1;
    std::cin.ignore();
    std::cin >> operation >> opd2;
    
    if ('/' == operation && 0 == opd2) {
        std::cerr << "Error. Division by zero.\n";
        return 0;
    }
    
    std::map<char, int> calculate {
      {'+', opd1 + opd2},
      {'-', opd1 - opd2},                                      
      {'*', opd1 * opd2},
      {'/', opd1 / opd2},
      {'^', pow(opd1, opd2)},
      {'%', static_cast<int>(opd1) % static_cast<int>(opd2)}
    };
    
    std::cout << calculate[operation];
    
    return 0;
}

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


Все довольно просто, но, по моему мнению, не совсем очевидно, что в качестве значений std::map в С++ или словарей в Python, мы можем использовать выражения.

#540_RUST_LIB_SDS_IdPt

Как в Rust считать цифры из stdin и записать их в вектор?

В Rust есть несколько способов считать числа из стандартного ввода (`stdin`) и поместить их в вектор (`Vec`).


Считывание одной строки чисел, разделённых пробелами.
Если числа вводятся в одной строке через пробел (например: `1 2 3 4 5`), то:

use std::io;

fn main() {
  let mut input = String::new();
  io::stdin().read_line(&mut input).expect("Не удалось прочитать строку");

  let numbers: Vec<i32> = input
    .trim()
    .split_whitespace()
    .map(|s| s.parse().expect("Некорректное число"))
    .collect();

  println!("{:?}", numbers);
}

Замечание: здесь используется `i32`, но можно заменить на `i64`, `f64` и т.д. в зависимости от нужного типа.


Считывание нескольких строк по одному числу в каждой.
Если каждое число вводится на отдельной строке, и известно количество чисел (например, сначала вводится `n`, потом `n` чисел):

use std::io;

fn main() {
  let mut n_input = String::new();
  io::stdin().read_line(&mut n_input).expect("Не удалось прочитать n");
  let n: usize = n_input.trim().parse().expect("Некорректное n");

  let mut numbers = Vec::new();
  for _ in 0..n {
    let mut line = String::new();
    io::stdin().read_line(&mut line).expect("Не удалось прочитать число");
    let num: i32 = line.trim().parse().expect("Некорректное число");
    numbers.push(num);
  }

  println!("{:?}", numbers);
}

Считывание всех чисел до конца ввода (EOF).
Если нужно считывать до конца ввода (например, при перенаправлении из файла или Ctrl+D в терминале):

use std::io::{self, BufRead};

fn main() {
  let stdin = io::stdin();
  let numbers: Vec<i32> = stdin
    .lock()
    .lines()
    .map(|line| line.expect("Ошибка чтения строки"))
    .flat_map(|line| {
      line.split_whitespace()
        .map(|s| s.parse::<i32>().expect("Некорректное число"))
    })
    .collect();

  println!("{:?}", numbers);
}

Этот вариант обрабатывает все строки, разбивая каждую на числа (если в строке несколько чисел через пробел).


Обработка ошибок (более надёжно).
Чтобы избежать паники при ошибке парсинга:

use std::io;

fn main() {
  let mut input = String::new();
  io::stdin().read_line(&mut input).expect("Не удалось прочитать строку");

  let numbers: Result<Vec<i32>, _> = input
    .trim()
    .split_whitespace()
    .map(|s| s.parse::<i32>())
    .collect();

  match numbers {
    Ok(nums) => println!("{:?}", nums),
    Err(e) => eprintln!("Ошибка парсинга: {}", e),
  }
}

.

#541_RUST_LIB_SDS_IdPt

Как в Rust считать каждую цифру числа, которое считывается из stdin, как элемент вектора?

Если необходимо считать одно большое число как строку, а затем разбить его на отдельные цифры и сохранить каждую как элемент вектора (например, `[1, 2, 1, 3, 4, 3, 4, 5, 6, 7, 5, 3, 4, 8, 9, 0, 0, 3]`), то в Rust это делается очень просто — без парсинга в целое число, потому что число может быть слишком большим для любого примитивного типа (u128 и т.п.).


Решение:
Считываем строку и преобразуем каждый символ в цифру:

use std::io;

fn main() {
  let mut input = String::new();
  io::stdin().read_line(&mut input).expect("Не удалось прочитать строку");

  let digits: Vec<u8> = input
    .trim()
    .chars()
    .map(|c| c.to_digit(10).expect("Некорректный символ (не цифра)") as u8)
    .collect();

  println!("{:?}", digits);
}

Объяснение:
— input.trim() — убирает символы новой строки и пробелы по краям.
— .chars() — перебирает каждый символ в строке.
— .to_digit(10) — пытается преобразовать символ в цифру (возвращает `Option<u32>`).
— expect(...) — завершит программу с ошибкой, если встретится нецифровой символ (например, буква).
— as u8 — приводим к u8, так как цифры от 0 до 9 легко помещаются в один байт.

Если необходимо хранить цифры как i32 или u32 — просто убираем as u8 и оставляем u32:

let digits: Vec<u32> = input.trim().chars().map(|c| c.to_digit(10).expect("...")).collect();

Безопасный вариант (без паники):

use std::io;

fn main() {
  let mut input = String::new();
  io::stdin().read_line(&mut input).expect("Не удалось прочитать строку");

  let digits: Result<Vec<u8>, _> = input
    .trim()
    .chars()
    .map(|c| {
      c.to_digit(10)
        .map(|d| d as u8)
          .ok_or_else(|| format!("Недопустимый символ: '{}'", c))
    })
    .collect();

  match digits {
    Ok(v) => println!("{:?}", v),
    Err(e) => eprintln!("Ошибка: {}", e),
  }
}

Пример ввода/вывода:
Ввод:

121343456753489003

Вывод:

[1, 2, 1, 3, 4, 3, 4, 5, 6, 7, 5, 3, 4, 8, 9, 0, 0, 3]

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

#542_C_Cpp_IdPt_IF

Я тут увидел в исходнике в одной книжке что функция main() предварительно объявляется, ну т.е.:

int main(int argc, char** argv):
// и далеее
int main(int argc, char** argv) {
  //Тело функции main
  return 0;
}

Мне и стало интересно, если она объявляется как обычная функция, то можно ли вызвать ее рекурсивно.

Решил провести эксперимент, набросал вот такой код:

#include <stdio.h>

int main(int argc, char** argv) {
  int returnValue;
  if (argc == 2) {
    sscanf(argv[1], "%d", &returnValue);
  }
  if (returnValue == 0) {
    return returnValue;
  }
  --returnValue;
  argv[1][0] = '0' + returnValue;
  printf("argv[1] = %s, returnValue = %d\n", argv[1], returnValue);
  return main(argc, argv);
}

И как не удивительно это работает. 😁👍.

В результате работы программы получаем вот такой вывод:

compukter@barracol:~/Programs/C/edu_task$ ./a.out 9
argv[1] = 8, returnValue = 8
argv[1] = 7, returnValue = 7
argv[1] = 6, returnValue = 6
argv[1] = 5, returnValue = 5
argv[1] = 4, returnValue = 4
argv[1] = 3, returnValue = 3
argv[1] = 2, returnValue = 2
argv[1] = 1, returnValue = 1
argv[1] = 0, returnValue = 0

.

#543_C_Cpp_ALG_IdPt

Алгоритмы. "Эталонная" реализация Bubble Sort (пузырьковой сортировки) с досрочным завершением, если вектор (массив) уже отсортирован, на С/С++:

#include <iostream>
#include <vector>
#include <utility>   // std::swap
#include <cstddef>   // std::size_t

/**
 * @brief Пузырьковая сортировка с ранним выходом.
 * 
 * Алгоритм сортирует контейнер по возрастанию.
 * Оптимизирован: если за проход не было обменов — массив уже отсортирован.
 * 
 * @tparam Container тип контейнера (например, std::vector<int>)
 * @param arr ссылка на контейнер, который будет отсортирован
 */
template<typename Container>
void bubbleSort(Container& arr) {
  const std::size_t n = arr.size();
  if (n <= 1) return; // Пустой или одноэлементный контейнер уже отсортирован

  bool swapped;
  for (std::size_t i = 0; i < n - 1; ++i) {
    swapped = false;
    // Последние i элементов уже на месте
    for (std::size_t j = 0; j < n - 1 - i; ++j) {
      if (arr[j] > arr[j + 1]) {
        std::swap(arr[j], arr[j + 1]);
        swapped = true;
      }
    }
    if (!swapped) break; // Ранний выход — массив отсортирован
  }
}

// Специализация для ввода: читаем std::vector<int>
bool readVector(std::vector<int>& numbers) {
  std::size_t size = 0;
  if (!(std::cin >> size)) {
    std::cerr << "Error: invalid or missing input size.\n";
    return false;
  }

  numbers.resize(size);
  for (auto& num : numbers) {
    if (!(std::cin >> num)) {
      std::cerr << "Error: failed to read a number from input.\n";
      return false;
    }
  }
  return true;
}

int main() {
  std::vector<int> numbers;
  if (!readVector(numbers)) {
    return EXIT_FAILURE;
  }

  bubbleSort(numbers);

  // Вывод без завершающего пробела
  for (std::size_t i = 0; i < numbers.size(); ++i) {
    if (i != 0) {
      std::cout << ' ';
    }
    std::cout << numbers[i];
  }
  std::cout << '\n';

  return EXIT_SUCCESS;
}

.

#544_C_IdPt_TP

C — idioms!

Термин "C idioms" (идиомы C) означает устоявшиеся, идиоматические (привычные для опытных программистов на C) паттерны написания кода, которые обеспечивают:

— Безопасность (предотвращение утечек, разыменования NULL, переполнений),
— Портабельность,
— Читаемость для других C-разработчиков,
— Эффективность,
— Согласованность с философией языка C.


Основные идиомы C, сгруппированные по категориям.

Работа с памятью.

1. malloc через sizeof *ptr

T *p = malloc(sizeof *p * n);

Почему:
не зависит от типа T, не нужно дублировать имя типа. Безопасно при рефакторинге.

Пример:

int *arr = malloc(sizeof *arr * 10); // выделяет 10 int'ов
Node *node = malloc(sizeof *node);   // выделяет 1 узел

Плохо:
malloc(sizeof(Node) * n) — дублирование имени, риск ошибки.


2. Всегда проверяй результат malloc

void *p = malloc(n);
if (!p) {
    // обработка ошибки: exit, return error code, etc.
}

В embedded или специализированных системах иногда пропускают, но в общем случае — обязательно.


3. Инициализация после malloc — используй calloc или memset если нужна обнулённая память:

int *arr = calloc(n, sizeof *arr); // автоматически обнуляет

Или:

int *arr = malloc(sizeof *arr * n);
if (arr) memset(arr, 0, sizeof *arr * n);

4. Освобождение и обнуление указателя (defensive programming)

free(ptr);
ptr = NULL; // предотвращает использование "висячего" указателя

Особенно полезно в крупных функциях или при повторном использовании переменной.




Работа с указателями и структурами.

1. Используй typedef для структур (но осторожно!)

typedef struct node {
  int data;
  struct node *next;
} Node;

Позволяет писать Node *, а не struct node * — чище.
Но некоторые purists (например, Linus Torvalds) против, т.к. скрывает тот факт, что это структура.
Однако в большинстве проектов — принято.


2. Передача структур: по указателю, если модифицируешь

void modify_list(List *l); // изменяет список
void print_list(const List *l); // не изменяет

Передача по значению (List l) копирует всю структуру — дорого, если она большая.


3. Используй const агрессивно

int get_size(const List *l); // обещаешь не менять

Помогает компилятору, предотвращает ошибки, улучшает интерфейс.


3. Циклы и итерации

1. Идиома обхода связного списка

for (Node *p = head; p != NULL; p = p->next) {
    // обработка
}

Коротко, читаемо, идиоматично.


2. Освобождение списка

while (head) {
  Node *next = head->next;
  free(head);
  head = next;
}

Не теряешь указатель на следующий узел до освобождения текущего.



Работа с файлами и вводом-выводом.

1. Проверка scanf, fopen, fread

if (scanf("%d", &x) != 1) { /* ошибка */ }
if ((fp = fopen("file", "r")) == NULL) { /* ошибка */ }

Никогда не предполагай, что ввод/файл успешен.


2. Чтение строк — fgets, а не gets

char buf[256];
if (fgets(buf, sizeof buf, stdin)) {
  // обрезать \n при необходимости
}

gets — запрещён (уязвимость к переполнению буфера).


.

Функции и интерфейсы

1. Возвращай коды ошибок (или используй exit)

int create_list(List *l); // возвращает 0 при успехе, -1 при ошибке

Альтернатива — аварийное завершение (exit) при критических ошибках (например, malloc failed).


2. Инициализация через составной литерал или функцию

List l = {0}; // все поля = 0 / NULL
// или
List l = make_list();

{0} — стандартный способ обнулить структуру.



Макросы и препроцессор (осторожно!).

1. Защита от повторного включения

#ifndef MY_HEADER_H
#define MY_HEADER_H
// содержимое
#endif

Стандарт для заголовочных файлов.


2. Макросы для мин/макс (осторожно: avoid side effects!)

#define MIN(a, b) ((a) < (b) ? (a) : (b))

Но лучше использовать функции, если типы известны.



Безопасность и надёжность.

1. Избегай "магических чисел":

#define MAX_NODES 1000

Улучшает читаемость и поддержку.


2. Используй size_t для размеров и индексов:

for (size_t i = 0; i < n; i++) // n — размер массива

size_t — беззнаковый тип, возвращаемый sizeof, strlen, malloc и т.д.

Но будь осторожен при сравнении с int — возможны неожиданные преобразования.


3. Проверяй границы массивов (если не используешь безопасные абстракции)
C не проверяет границы — это твоя забота.



Современные (C99/C11) идиомы.

1. Объявление переменных в заголовке цикла

for (int i = 0; i < n; i++) // i виден только в цикле

Чисто, локально, безопасно.


2. Designated initializers (C99)

struct Point p = {.x = 10, .y = 20};
List l = {.first = NULL, .last = NULL, .size = 0};

Читаемо и явно.


3. Compound literals (C99)

draw_point((struct Point){.x = 5, .y = 5});

Полезно для временных объектов.



Ошибки, которых стоит избегать (анти-идиомы):

void main() — не стандартно. Используй

int main(void) {}

или

int main(int argc, char *argv[])

Приведение malloc:

int* pi = (int*)malloc(size * sizeof(int));

В C не нужно, может скрыть ошибку, если забыть
#include <stdlib.h>


Игнорирование возвращаемого значения scanf, fopen — ведёт к UB или зацикливанию.


fflush(stdin) — неопределённое поведение (только для outputStreams!).


Возврат указателя на локальную переменную — указывает в "никуда" после выхода из функции.



C idioms — это не просто "как писать", а "как писать правильно в духе C":
— минимализм,
— явность,
— контроль над ресурсами,
— доверяй, но проверяй,
— компилятор — друг, но не замена внимательности.

Изучение и применение этих идиом делает код:
— надёжным,
— понятным другим C-программистам,
— легко поддерживаемым.

#545_GO_IdPt_TP

Как в Go идиоматически верно считывать данные из стандартного вввода.


В Go идиоматически считывать данные из стандартного ввода os.Stdin можно несколькими способами, в зависимости от того, что именно необходимо считать:


1. Считать всю строку (включая пробелы)
Используйте bufio.Scanner — это самый распространённый и идиоматичный способ:

package main

import (
  "bufio"
  "fmt"
  "os"
)

func main() {
  scanner := bufio.NewScanner(os.Stdin)
  fmt.Print("Введите строку: ")
  if scanner.Scan() {
    line := scanner.Text()
    fmt.Println("Вы ввели:", line)
  }
  if err := scanner.Err(); err != nil {
    fmt.Fprintln(os.Stderr, "Ошибка при чтении:", err)
  }
}

✅ Подходит для построчного ввода.
⚠️ Не подходит для чтения бинарных данных или очень длинных строк (ограничение по умолчанию ~64 КБ).


2. Считать отдельные слова или токены
Если нужно читать по словам (разделённым пробелами), можно использовать fmt.Scan или fmt.Scanf:

var word string
fmt.Print("Введите слово: ")
_, err := fmt.Scan(&word)
if err != nil {
  fmt.Fprintln(os.Stderr, "Ошибка:", err)
  return
}
fmt.Println("Вы ввели:", word)

Для нескольких значений:

var a, b int
fmt.Scan(&a, &b) // читает два целых числа

✅ Просто и удобно для парсинга структурированного ввода.
❌ Не подходит для строк с пробелами (только до первого пробела).


3. Считать всё содержимое stdin сразу
Если нужно прочитать весь ввод целиком (например, из pipe):

data, err := io.ReadAll(os.Stdin)
if err != nil {
  fmt.Fprintln(os.Stderr, "Ошибка:", err)
  return
}
fmt.Printf("Получено %d байт: %s\n", len(data), string(data))

⚠️ Осторожно: может быть опасно при большом объёме данных (например, если stdin — бесконечный поток).


4. Чтение побайтово или поблочно
Если нужен низкоуровневый контроль:

buffer := make([]byte, 1024)
n, err := os.Stdin.Read(buffer)
if err != nil && err != io.EOF {
  fmt.Fprintln(os.Stderr, "Ошибка:", err)
}
fmt.Printf("Прочитано %d байт: %s\n", n, string(buffer[:n]))

Используется редко, только при необходимости.


Рекомендации:

— Для интерактивного ввода строк → bufio.Scanner.
— Для парсинга чисел/слов → fmt.Scan.
— Для обработки всего stdin (например, как фильтр) → io.ReadAll.

#546_Cpp_GO_RUST_IdPt_TP

Что общего и в чем различия между методами класса или структуры в С++ и трейтами в Rust или интерфейсами в Go?


Давайте рассмотрим аналогию с монолитной и микросервисной архитектурой.
Действительно, можно представить различия между классами и методами в C++ и трейтами в Rust следующим образом:

Класс и методы в C++:
Представьте большой монолитный сервер, который несет в себе и интерфейс (контракт), и всю необходимую реализацию сразу внутри себя. Этот сервер не только описывает API, но и сам предоставляет готовую бизнес-логику и функции. В случае с классами в C++ это моноблок, в котором совмещены:
— Контракты (интерфейсы, методы, свойства).
— Реализации этих контрактов (код методов).

Класс как единый монолитный объект, в котором собрано всё сразу: спецификация поведения и готовые реализации методов.


Трейты в Rust или интерфейсы в Go:
Представь систему микросервисов, где сервис-интерфейс выступает как декларация соглашения (API), а сервисы-реализации — это отдельные микросервисы, которые предоставляют функциональные блоки, совместимые с этим соглашением.

Трейты и интерфейсы:
— Только объявляют контракт (описывают методы и поведение).
— Сами не содержат никакой реализации.
— Реализация методов предоставляется отдельными типами, которые хотят поддержать этот контракт.

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


Монолитный подход (класс и методы в C++) противопоставляется микромодульному подходу (трейты в Rust, интерфейсы в Go).
Монолитные классы собирают в себе контракт и реализацию, тогда как трейты и интерфейсы предоставляют чистый контракт, оставляя реализацию типам данных, реализующим этот контракт.

#547_IF

Новый авторский сленговый термин интересно приживется или нет.

"ПОДОКОННИК" — человек пользующийся Windows (работающий "под "Окнами") ✌️😂.

#548_Cpp_LIB_Boost


Boost.Program_options — библиотека для работы с параметрами командной строки и конфигурационными файлами в C++.


Boost.Program_options позволяет легко обрабатывать аргументы командной строки, конфигурационные файлы и переменные окружения.

✅ Установка Boost.Program_options

1. Загрузка Boost:
— Скачайте последнюю версию Boost на официальном сайте https://www.boost.org

2. Распаковка архива:
— Распакуйте архив в удобное место на вашем компьютере.

3. Сборка Boost:
— Перейдите в папку с распакованным Boost.
— Запустите команду для сборки библиотеки:

./bootstrap.sh
./b2

Это создаст необходимые библиотеки и заголовочные файлы.

4. Установка Boost:
— После успешной сборки выполните команду для установки:

sudo ./b2 install

Это установит Boost в системные каталоги.

✅ Подключение Boost.Program_options.

1. Добавление заголовочных файлов:
— Добавьте заголовочные файлы Boost.Program_options:

#include <boost/program_options.hpp>

2. Подключение библиотеки:
— При компиляции программы укажите путь к библиотекам Boost и добавьте библиотеку program_options:

g++ -o my_program my_program.cpp -lboost_program_options

✅ Использование Boost.Program_options.

Рассмотрим пример использования Boost.Program_options для обработки параметров командной строки.

Пример программы:

#include <iostream>
#include <boost/program_options.hpp>

namespace po = boost::program_options;

int main(int argc, char* argv[]) {
  // Описание опций
  po::options_description desc("Allowed options");
  desc.add_options()
    ("help,h", "produce help message")
    ("input-file,i", po::value<std::string>(), "input file")
    ("output-file,o", po::value<std::string>(), "output file")
  ;

  // Переменные для хранения значений опций
  po::variables_map vm;
  po::store(po::parse_command_line(argc, argv, desc), vm);
  po::notify(vm);

  // Обработка опций
  if (vm.count("help")) {
    std::cout << desc << std::endl;
    return 1;
  }

  if (vm.count("input-file")) {
    std::cout << "Input file: " << vm["input-file"].as<std::string>() << std::endl;
  }

  if (vm.count("output-file")) {
    std::cout << "Output file: " << vm["output-file"].as<std::string>() << std::endl;
  }

  return 0;
}

Объяснение кода:
1. Описание опций:
— Создаем объект options_description и добавляем к нему описания опций.

2. Переменные для хранения значений:
— Используем variables_map для хранения значений опций.

3. Обработка опций:
— Проверяем наличие опций и выводим соответствующие сообщения.


Запуск программы:

./my_program --input-file input.txt --output-file output.txt

Вывод:

Input file: input.txt
Output file: output.txt

Boost.Program_options предоставляет мощный и удобный способ обработки параметров командной строки и конфигурационных файлов в C++.
Следуя этим шагам, можно легко установить, подключить и использовать эту библиотеку в своих проектах.

#549_Cpp_TLS


Существуют ли системы инфраструктуры для С++, которые объединяли бы совокупность инструментов для форматирования, компиляции, тестирования, управления зависимостями, системами сборки, анализаторами и т.д. (системы подобные cargo в Rust или инфраструктура Golang -- единый go toolchain)?

В отличие от Rust (cargo) и Go (единый go toolchain), в экосистеме C++ нет единой официальной системы, объединяющей все аспекты разработки. Это следствие исторического развития языка, философии «разделяй и властвуй» и отсутствия централизованного управления стандартом. Однако существуют современные подходы к интеграции инструментов, которые приближаются к удобству cargo. Рассмотрим их структурированно.


🔍 Почему в C++ нет «единого инструмента»?

| Фактор | Пояснение |
|--------|-----------|
| Историческая фрагментация | C++ развивался десятилетиями без единого менеджера пакетов или билд-системы (в отличие от Go 2009 или Rust 2010). |
| Философия языка | Комитет по стандартизации (ISO) фокусируется на языке, а не на инструментах. «Не навязывай решения» — ключевой принцип. |
| Разнообразие платформ | Встраиваемые системы, консоли, HPC требуют разных билдеров и линковщиков — сложно создать универсальный инструмент. |
| Культура «лучшего инструмента» | Сообщество предпочитает специализированные утилиты (например, clang-format для форматирования, CMake для сборки), а не монолит. |


🧩 Современные подходы к «единым» системам

1. Conan + CMake + инструменты экосистемы LLVM — *де-факто стандарт для кросс-платформенной разработки*

# Пример рабочего процесса
conan install . --output-folder=build --build=missing  # управление зависимостями
cd build && cmake .. -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake  # генерация билда
cmake --build .  # сборка
ctest --output-on-failure  # тестирование
clang-format -i src/*.cpp  # форматирование
clang-tidy src/*.cpp -- -Iinclude  # статический анализ

| Компонент | Инструмент | Роль |
|-----------|------------|------|
| Управление зависимостями | [Conan](https://conan.io) | Централизованный менеджер пакетов с бинарными кэшами |
| Сборка | [CMake](https://cmake.org) + [Ninja](https://ninja-build.org) | Генерация билд-файлов и быстрая сборка |
| Форматирование | clang-format | Единый стиль кода через .clang-format |
| Статический анализ | clang-tidy, cppcheck | Поиск багов и антипаттернов |
| Тестирование | GoogleTest, Catch2 | Интеграция через CTest |
| CI/CD | GitHub Actions + Conan Center | Автоматическая сборка под 10+ платформ |

✅ Преимущества: кросс-платформенность, поддержка бинарных кэшей, интеграция с CI.
⚠️ Недостатки: требуется ручная настройка интеграции инструментов (нет единой команды вроде cargo build).


2. Bazel (Google) — *монолитная система «всё-в-одном»*

# BUILD.bazel
cc_binary(
    name = "tetris",
    srcs = ["main.cpp", "game.cpp"],
    deps = ["@gtest//:gtest"],
    copts = ["-std=c++20"],
)

# WORKSPACE.bazel
load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
http_archive(name = "gtest", urls = [...])

| Возможности | Описание |
|-------------|----------|
| Единая команда | bazel build //:tetris, bazel test //... |
| Управление зависимостями | Через WORKSPACE + remote repositories |
| Кэширование | Глобальный кэш на уровне хэшей артефактов |
| Расширяемость | Skylark — встроенный язык для кастомных правил |
| Поддержка | Официальная поддержка от Google, используется в TensorFlow, Android |

✅ Преимущества: максимальная воспроизводимость, масштабируемость до миллионов файлов.
⚠️ Недостатки: крутая кривая обучения, избыточность для небольших проектов.


3. Buck2 (Meta) — современная альтернатива Bazel

- Написан на Rust → высокая производительность
- Поддержка C++20/23 «из коробки»
- Активно развивается Meta (используется в Instagram, WhatsApp)
- Пример конфигурации: BUCK файлы в формате Starlark

# BUCK
cxx_binary(
    name = "tetris",
    srcs = glob(["src/*.cpp"]),
    headers = subdir_glob([("include", "**/*.h")]),
    deps = [":tetris_lib", "//third-party/gtest:gtest"],
)

4. Meson + WrapDB -- минималистичный подход

# meson.build
project('tetris', 'cpp', version: '1.0')
tetromino = library('tetromino', 'src/tetromino.cpp')
executable('tetris', 'src/main.cpp', link_with: tetromino)

- Встроенный менеджер зависимостей (wrap-файлы через [WrapDB](https://wrapdb.mesonbuild.com))
- Единая команда: meson setup build && meson compile -C build
- Поддержка clang-format и clang-tidy через meson format / meson analyze (начиная с v1.3.0)


5. build2 — *менее известный, но амбициозный проект*

bdep init ?sys:libhello  # инициализация + зависимость
b                       # сборка
b test                  # тестирование
b install               # установка

- Единый CLI (b, bdep)
- Встроенный менеджер пакетов (bpkg)
- Поддержка модульной системы сборки
- ⚠️ Меньше сообщества и документации по сравнению с Conan/Bazel


📊 Сравнительная таблица решений

| Система | Единый CLI | Менеджер пакетов | Сборка | Форматирование | Стат. анализ | Поддержка | Рекомендация |
|---------|------------|------------------|--------|----------------|--------------|-----------|--------------|
| Conan + CMake | ❌ (комбинация) | ✅ (Conan Center) | ✅ (Ninja) | ✅ (clang-format) | ✅ (clang-tidy) | Высокая | Универсальный выбор для продакшена |
| Bazel | ✅ | ✅ (remote repos) | ✅ | ✅ (через правила) | ✅ (аспекты) | Высокая (корпоративная) | Крупные проекты, монорепозитории |
| Buck2 | ✅ | ✅ | ✅ | ✅ | ✅ | Растущая | Современные проекты от Meta |
| Meson | ✅ | ✅ (WrapDB) | ✅ | ✅ (v1.3+) | ✅ (v1.3+) | Средняя | Небольшие/средние проекты |
| build2 | ✅ | ✅ | ✅ | ❌ | ❌ | Низкая | Экспериментальные проекты |
| vcpkg + CMake | ❌ | ✅ (Microsoft) | ✅ | ❌ | ❌ | Средняя | Проекты в экосистеме Microsoft |


🚀 Перспективы: движение к «единым» инструментам

1. CMake Presets (v3.19+) — унификация конфигурации сборки:

   // CMakePresets.json
   {
     "configurePresets": [{
       "name": "dev",
       "binaryDir": "build",
       "cacheVariables": { "CMAKE_BUILD_TYPE": "Debug" }
     }]
   }
   

→ cmake --preset dev && cmake --build --preset dev

2. Стандартизация модулей C++20 — потенциальная основа для будущего менеджера пакетов на уровне компилятора.

3. Инициатива C++ Alliance — обсуждения создания официального инструментария (пока на стадии дискуссий).

4. Conan 2.0 — упрощение интерфейса, интеграция с CMake Presets, поддержка модулей C++20.


💡 Рекомендация для продакшн-проекта

Для большинства команд оптимальный стек сегодня:

# Единая точка входа через скрипт или Makefile
./scripts/build.sh        # → вызывает Conan + CMake + Ninja
./scripts/test.sh         # → запускает ctest + clang-tidy
./scripts/format.sh       # → применяет clang-format

Содержимое build.sh:

#!/bin/bash
conan install . --output-folder=build --build=missing
cmake --preset conan-release -B build
cmake --build build --config Release

Такой подход:
- ✅ Сохраняет гибкость выбора инструментов
- ✅ Обеспечивает воспроизводимость через бинарные кэши Conan
- ✅ Интегрируется с любым CI/CD
- ✅ Позволяет легко заменить компонент (например, перейти с clang-format на uncrustify)


🔚 Вывод

В отличие от Rust и Go, в C++ нет единого официального инструмента, но современные системы вроде Conan + CMake или Bazel/Buck2 позволяют создать унифицированный рабочий процесс. Ключевой тренд — не поиск «серебряной пули», а интеграция лучших инструментов через унифицированные интерфейсы (CMake Presets, Conan profiles, Bazel WORKSPACE). Для продакшн-кода рекомендуется использовать Conan + CMake + clang-* инструменты как наиболее зрелый и поддерживаемый стек.

550#_IF


Цитаты известных разработчиков.
Сотня самых ярких цитат о программировании от программистов.


0. Rick Coo
Программирование сегодня — это гонка разработчиков программ, стремящихся писать программы с большей и лучшей идиотоустойчивостью, и вселенной, которая пытается создать больше отборных идиотов. Пока вселенная побеждает.


1. Alan J. Perlis
Низкоуровневый язык — это когда требуется внимание к вещам, которые никак не связаны с программами на этом языке.


2. Waldi Ravens
Программирование на С похоже на быстрые танцы на только что отполированном полу людей с острыми бритвами в руках.


3. Mosher’s Law of Software Engineering
Не волнуйтесь, если что-то не работает. Если бы всё работало, вас бы уволили.


4. Bill Bryson
Для меня долгое время было загадкой, как что-то очень дорогое и технологичное может быть столь бесполезным. И вскоре я осознал, что компьютер — это глупая машина, обладающая способностями выполнять невероятно умные вещи, тогда как программисты — это умные люди, у которых талант делать невероятные глупости. Короче, они нашли друг друга.


5. Thomas C. Gale
В хорошем дизайне добавление чего-то стоит дешевле, чем сама эта вещь.


6. Yoggi Berra
В теории, теория и практика неразделимы. На практике это не так.


7. Keith Bostic
Perl — это тот язык, который одинаково выглядит как до, так и после RSA шифрования.


8. Alan Kay
Я изобрел понятие «объектно-ориентированный», и могу заявить, что не имел в виду C++.


9. Christopher Thompson
Иногда лучше остаться спать дома в понедельник, чем провести всю неделю в отладке написанного в понедельник кода.


10. Bill Gates
Измерять продуктивность программиста подсчетом строк кода — это так же, как оценивать постройку самолета по его весу.


11. Brian W. Kernighan
Отладка кода вдвое сложнее, чем его написание. Так что если вы пишете код настолько умно, насколько можете, то вы по определению недостаточно сообразительны, чтобы его отлаживать.


12. Larry Wall
Многие из вас знакомы с достоинствами программиста. Их всего три, и разумеется это: лень, нетерпеливость и гордыня.


13. Alan Kay
Большинство программ на сегодняшний день подобны египетским пирамидам из миллиона кирпичиков друг на друге и без конструктивной целостности — они просто построены грубой силой и тысячами рабов.


14. Linus Torvalds
Большинство хороших программистов делают свою работу не потому, что ожидают оплаты или признания, а потому что получают удовольствие от программирования.


15. Martin Golding
Всегда пишите код так, будто сопровождать его будет склонный к насилию психопат, который знает, где вы живете.


16. Harold Abelson
Программы должны писаться для людей, которые будут их читать, а машины, которые будут эти программы исполнять — второстепенны.


17. Larry Niven
Люди, которые думают, что ненавидят компьютеры, на самом деле ненавидят плохих программистов.


18. Waseem Latif
Если вы дадите человеку программу, то займете его на один день. Если вы научите человека программировать, то займете его на всю жизнь.


19. Alan J. Perlis
Язык, который не меняет вашего представления о программировании, недостоин изучения.


20. Douglas Rushkoff
Мы наблюдаем общество, которое все больше зависит от машин, но при этом использует их все неэффективнее.


21. Max Kanat-Alexander
Иногда лучшие программы создаются на бумажке. Запрограммировать их — второстепенная вещь.


22. Amit Kalantri
Отладка кода — это как охота. Охота на баги.


23. Martin Fowler
Любой дурак сможет написать код, который поймет машина. Хорошие программисты пишут код, который сможет понять человек.


24. Jazzwant
Программирование — это разбиение чего-то большого и невозможного на что-то маленькое и вполне реальное.


25. Richard P. Gabriel
Программисты — не математики, как бы нам этого ни хотелось.

.

26. Marijn Haverbeke
Программирование — это сложно. Основные правила, на которых все строится, очень просты, но по мере разработки программа сама начинает вводить свои правила и законы. Таким образом, программист строит лабиринт, в котором сам же может и потеряться.


27. Marijn Haverbeke
Функции, которые производят значения, легче комбинировать новыми способами, чем те, которые производят сайд-эффекты.


28. Edsger W. Dijkstra
Простота — залог надежности.


29. Robert C. Martin
Если вы хотите, чтобы код было легко и быстро писать — делайте его удобным для чтения.


30. Michael C. Feathers
Если вы хорошо отлаживаете программы, значит, вы провели много времени, делая это. Я не хочу уметь хорошо отлаживать программы.


31. Любой программист
Работает? Не трогай.


32. Bjarne Stroustrup
При помощи C вы легко можете выстрелить себе в ногу. При помощи C++ это сделать сложнее, но если это произойдёт, вам оторвёт всю ногу целиком.


33. David Jameson
Последние нововведения в C++ были созданы, чтобы исправить предыдущие нововведения.


34. James Gosling
Java — это C++, из которого убрали все пистолеты, ножи и дубинки.


35. Robert Sewell
Если бы в Java действительно работала сборка мусора, большинство программ бы удаляли сами себя при первом же запуске.


36. Bjarne Stroustrup
Есть всего два типа языков программирования: те, на которые люди всё время ругаются, и те, которые никто не использует.


37. C. MacConnell
Плохое имя метода сродни предвыборным обещаниям политиков. Вроде о чем-то оно говорит, но если задуматься — непонятно о чем.


38. Dave Thomas
Неработающая программа обычно приносит меньше вреда, чем работающая плохо.


39. R. S. Martin
Насколько проще было бы писать программы, если бы не заказчики.


40. Alexander Golov
Молодые специалисты не умеют работать, а опытные специалисты умеют не работать.


41. C. MacConnell
Почаще задавайте себе вопрос «Что мне скрыть?» и вы удивитесь, сколько проблем проектирования растает на ваших глазах.


42. Donald Knuth
Преждевременная оптимизация — корень всех зол.


43. Robert Martin
Чтобы написать чистый код, мы сначала пишем грязный код, а затем рефакторим его.


44. Edsger W. Dijkstra
Помимо математических способностей, жизненно важным качеством программиста является исключительно хорошее владение родным языком.


45. H. L. Mencken
Для каждой сложной задачи существует решение, которое является быстрым, простым и неправильным.


46. Bjarne Stroustrup
Механизмы управления доступом в С++ обеспечивают защиту от несчастного случая, но не от мошенников.


47. Jack Dorsey
Думаю, искусство программировать немногим сложнее других человеческих навыков. Программирование делает вас лучше точно так же, как вам помогают развиваться изучение иностранного языка, математики или чтение книг.


48. Volnik
Аналогично тому, как написание картины является искусством для души, так и написание программы является искусством для разума.


49. Steve McConnell
Тестирование не позволяет обнаружить такие ошибки, как создание не того приложения.

.