//gen_interface.go
//+build ignore
package main
import (
  "fmt"
  "go/types"
  "strings"
)

const template = `
type MyInterface interface {
  Get%s() %s
  Set%s(%s)
}`

func main() {
  types := []string{"Int", "String"}
  for _, t := range types {
    getter := fmt.Sprintf(template, strings.Title(t), t, strings.Title(t), t)
    fmt.Println(getter)
  }
}

listener, _ := net.Listen("tcp", ":8080") // слушаем входящие соединения
for {
  conn, _ := listener.Accept()          // принимаем новое соединение
  go handleConnection(conn)            // отправляем в отдельную горутину
}

func handleConnection(conn net.Conn) {
  buf := bufio.NewReader(conn)     // создаем буферированный reader
  for {
    line, err := buf.ReadBytes('\n') // читаем строку из соединения
    if err != nil {
       break
    }
    processData(line)               // обрабатываем полученные данные
  }
}

package main
import (
  "io"
  "fmt"
)

func convertToReaders(rw []io.ReadWriter) []io.Reader {
  readers := make([]io.Reader, len(rw)) // Создаем новый срез нужного размера
  for i, rwItem := range rw {
    readers[i] = io.Reader(rwItem)    // Присваиваем интерфейс Reader каждому элементу
  }
  return readers
}

func main() {
  rwSlice := []io.ReadWriter{ /* заполните необходимыми объектами */ }
  readerSlice := convertToReaders(rwSlice)
  fmt.Println(readerSlice)
}

— Правила эффективного программирования меняются в зависимости от части С++, которую вы используете.

— Директиве #define следует предпочесть константные объекты и перечисления (enum).

— Вместо имитирующих функции макросов, определенных через #define, лучше применять встроенные функции (inline).

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

— Компиляторы проверяют побитовую константность, но вы должны программировать, применяя логическую константность.

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

— Всегда вручную инициализируйте объекты встроенных типов, по
скольку С++ делает это не всегда.

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

— Избегайте проблем с порядком инициализации в разных единицах трансляции, заменяя нелокальные статические объекты локальными статическими объектами.

— Компилятор может неявно генерировать для класса конструктор по умолчанию, конструктор копирования, оператор присваивания и деструктор.

— Чтобы отключить функциональность, автоматически предоставляемую компилятором, объявите соответствующую функцию-член закрытой и не включайте ее реализацию. 
Наследование базовому классу типа UncopyaЬle - один из способов сделать это.
— Начиная с версии С++11 конструктор копирования и оператор присваивания можно исключить с помощью слова delete

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

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

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

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

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

— Пишите операторы присваивания так, чтобы они возвращали ссылку на *this.

— Убедитесь, что operator= правильно ведет себя, когда объект присваивается самому себе. Для этого можно сравнить адреса исходного и целевого объектов, аккуратно упорядочить предложения или применить идиому копирования обменом.

— Убедитесь, что все функции, оперирующие более чем одним объектом, ведут себя корректно при совпадении двух или более объектов.

— Копирующие функции должны гарантировать копирование всех членов-данных объекта и частей его базовых классов.

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

— Чтобы предотвратить утечку ресурсов, используйте объекты RAII, которые захватывают ресурсы в своих конструкторах и освобождают в деструкторах.

— Два часто используемых класса RAII - это tr1::shared_ptr и auto_ptr.
Обычно лучше остановить выбор на классе tr1::shared_ptr, потому что его поведение при копировании соответствует интуитивным ожиданиям.
Что касается auto_ptr, то после копирования он уже не указывает ни на какой объект.

— Копирование RАII-объектов влечет за собой копирование ресурсов, которыми они управляют, поэтому поведение ресурса при копировании определяет поведение RАII-объекта.

— Обычно при реализации RАII-классов применяется одна из двух схем: запрет копирования или подсчет ссылок, но возможны и другие варианты.

— Программные интерфейсы (API) часто требуют прямого обращения к ресурсам. Именно поэтому каждый RAII-клacc должен предоставлять возможность получения доступа к ресурсу, которым он управляет.

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

— Если вы используете [] в выражении new, то должны применять [] и в соответствующем выражении delete. Если вы не используете квадратные скобки [] в выражении new, то не должны использовать их и в соответствующем выражении delete.

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

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

— Для обеспечения корректного использования интерфейсы должны быть согласованы и совместимы со встроенными типами.

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

— Класс tr1::shared_ptr поддерживает пользовательские функции-чистильщики. Это снимает "проблему нескольких DLL" и может быть использовано для автоматического освобождения мьютекса (см. правило 14).

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

— Передаче по значению предпочитайте передачу по ссылке на константу.
Обычно это более эффективно и позволяет избежать проблемы "срезки".

— Это правило не касается встроенных типов, итераторов и функциональных объектов STL.
Для них передача по значению обычно подходит больше.

— Никогда не возвращайте указатель или ссылку на локальный объект, ссылку на объект, распределенный в "куче", либо указатель или ссылку на локальный статический объект, если есть шанс, что понадобится более, чем один экземпляр такого объекта. (в правиле 4 приведен пример ситуации, когда возврат ссылки на локальный статический объект имеет смысл, по крайней мере, в однопоточных средах).

— Объявляйте данные-члены закрытыми (private).
Это дает клиентам синтаксически однородный доступ к данным, обеспечивает возможность тонкого управления доступом, позволяет гарантировать инвариантность и предоставляет авторам рсализации классов гибкость.

— Защищенные члены не более инкапсулированы, чем открытые.

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

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

— Предоставьте функцию-член swap, если std::swap работает с новым типом неэффективно.
Убедитесь, что она не возбуждает исключений.

— Если вы предоставляете функцию-член swap, то также предоставьте свободную функцию, вызывающую функцию-член. Для классов (не шаблонов) специализируйте также std::swap.

— Когда вызывается swap, используйте using-объявление, вводящее std::swap в область видимости, и вызывайте swap без квалификатора пространства имен.

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

— Откладывайте определение переменных насколько возможно. Это делает программы яснее и повышает их эффективность.

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

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

— Предпочитайте приведения в стиле С++ старому стилю. Их легче увидеть, и они более избирательны.

— Избегайте возвращать «дескрипторы» (ссылки, указатели, итераторы) внутренних данных объекта.
Это повышает степень инкапсуляции, помогает константным функциям-членам быть константными и минимизирует вероятность появления «висячих дескрипторов».

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

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

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

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

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

— Основная идея уменьшения зависимостей на этапе компиляции состоит в том, чтобы заменить зависимость от определения зависимостью от объявления.
Эта идея лежит в основе двух подходов: классов-дескрипторов и интерфейсных классов.

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

— Открытое наследование означает «является». Все, что применимо к базовому классу, должно быть применимо также и к производным от него классам, потому что каждый объект производного класса является также объектом базового класса.

— Имена в производных классах скрывают имена из базовых классов.
При открытом наследовании это всегда нежелательно.

— Чтобы сделать скрытые имена видимыми, используйте using-объявления либо перенаправляющие функции.

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

— Чисто виртуальные функции означают, что наследуется только интерфейс.

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

— Невиртуальные функции означают, что наследуются интерфейс и обязательная реализация.

— К числу альтернатив виртуальным функциям относятся идиома NVI и различные формы паттерна проектирования "Стратегия".
Идиома NVI сама по себе - это пример реализации паттерна "Шаблонный Метод".

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

— Объекты tr1::function работают как обобщенные указатели на функции.
Такие объекты поддерживают все вызываемые сущности, совместимые с сигнатурой целевой функции.

— Никогда не переопределяйте наследуемые невиртуальные функции.

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

— Семантика композиции кардинально отличается от семантики открытого наследования.

— В предметной области композиция означает "содержит".
В области реализации она означает "реализовано посредством".

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

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

— Множественное наследование сложнее одиночного.
Оно может привести к неоднозначности и необходимости применять виртуальное наследование.

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

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

— И классы, и шаблоны поддерживают интерфейсы и полиморфизм.

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

— Для параметров шаблонов интерфейсы неявны и основаны на корректных выражениях.
Полиморфизм проявляется во время компиляции - через конкретизацию и разрешение перегрузки функций.

— В объявлениях параметров шаблона ключевые слова class и typename взаимозаменяемы.

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

— В шаблонах производных классов ссылки на имена из шаблонов базовых классов осуществляются с помощью префикса "this->". using-объявления либо посредством явного указания базового класса.

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

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

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

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

— Если вы объявляете шаблоны обобщенных конструкторов копирования или обобщенного оператора присваивания, то по-прежнему должны объявить обычный конструктор копирования и оператор присваивания.

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

— Классы-характеристики делают доступной информацию о типах во время компиляции.
Они реализованы с применением шаблонов и их специализаций.

— В сочетании с перегрузкой классы-характеристики позволяют проверять типы во время компиляции.

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

— Технология ТМР может быть использована для генерации кода на основе комбинации политик, а также чтобы предотвратить генерацию кода, некорректного для определенных типов данных.

— set_new_handler позволяет указать функцию, которая должна быть вызвана, если запрос на выделение памяти не может быть удовлетворен.

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

— Есть много причин для написания специальных версий new и delete, включая повышение производительности, отладку ошибок при работе с кучей, а также сбор информации об использовании памяти.

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

— Оператор delete не должен ничего делать при передаче ему нулевого указателя.
Версии оператора delete уровня класса должны обрабатывать запросы на освобождение блоков, которые больше, чем ожидается.

— Когда пишете размещающую версию оператора new, убедитесь, что не забыли о соответственном размещающем операторе delete.
Если его не будет, то в программе могут возникать тонкие, трудноуловимые утечки памяти.

— Объявляя размещающие версии new и delete, позаботьтесь о том, чтобы нечаянно не скрыть нормальных версий этих функций.

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

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

—  Основная функциональность стандартной библиотеки С++ состоит из STL, потоков iostream и локалей. Также включена стандартная библиотека С99.

— TR1 добавляет поддержку "интеллектуальных" указателей (например, tr1::shared_ptr), обобщенных указателей на функции (tr1::function), кэшированных контейнеров, регулярных выражений и еще 10 компонентов.

— Отчет TR1 сам по себе - всеrо лишь спецификация.
Чтобы воспользоваться преимуществами TR1, понадобится реализация. Одним из источников реализаций компонентов TR1 является проект Boost.

— Boost - сообщество и WеЬ-сайт для разработки бесплатных библиотек на С++ с открытыми исходными текстами, подверrающихся публичному обсуждению.
Boost оказывает немалое влияние на процедуру стандартизации С++.

— Boost предоставляет реализацию многих компонентов TR1, но - кроме того - и множество друrих библиотек.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

#define PORT 8080

void handle_client(int client_socket) {
  char buffer[1024];
  ssize_t bytes_read = recv(client_socket, buffer, sizeof(buffer)-1, 0);
  if(bytes_read > 0) {
    buffer[bytes_read] = '\0';
    printf("Received request:\n%s\n", buffer);
        
    // Send a simple response back to the client
    const char* response =
      "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"
      "<html><body><h1>Hello from C Web Server!</h1></body></html>";
    send(client_socket, response, strlen(response), 0);
  }
    
  close(client_socket); // Close connection after sending response
}

int main() {
  int server_fd, new_socket;
  struct sockaddr_in address;
  int opt = 1;
  int addrlen = sizeof(address);
    
  // Create socket file descriptor
  if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
    perror("socket failed");
    exit(EXIT_FAILURE);
  }
    
  // Forcefully attaching socket to port 8080
  if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
    perror("setsockopt");
    exit(EXIT_FAILURE);
  }
    
  address.sin_family = AF_INET;
  address.sin_addr.s_addr = INADDR_ANY;
  address.sin_port = htons(PORT);
    
  // Bind the socket to the specified IP and port
  if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0 ) {
    perror("bind failed");
    exit(EXIT_FAILURE);
  }
    
  // Listen for incoming connections
  if (listen(server_fd, 3) < 0) {
    perror("listen");
    exit(EXIT_FAILURE);
  }
    
  while(1) { // Accept multiple clients
    if ((new_socket = accept(server_fd, (struct sockaddr *)NULL, NULL)) < 0) {
      perror("accept");
      continue;
    }
        
    handle_client(new_socket);
  }
    
  return 0;
}

#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
#include <string>
#include <arpa/inet.h>

using namespace std;

const string default_response =
"RFC 2616 compliant HTTP Response\r\n"
"HTTP/1.1 200 OK\r\n"
"Server: Simple C++ Web Server\r\n"
"Content-Length: 26\r\n"
"\r\n"
"<h1>Hello from C++!</h1>\r\n";

// Handle incoming requests
void handleRequest(int sockfd) {
  char buffer[1024];
  memset(buffer, 0, sizeof(buffer));
  ssize_t n = read(sockfd, buffer, sizeof(buffer)-1);
  cout << "Client Request:" << endl << buffer << endl;
    
  write(sockfd, default_response.c_str(), default_response.length());
  close(sockfd);
}

int main() {
  int listenfd, connfd;
  struct sockaddr_in servaddr;
    
  listenfd = socket(AF_INET, SOCK_STREAM, 0);
  bzero(&servaddr, sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  servaddr.sin_port = htons(8080);
    
  bind(listenfd, reinterpret_cast<const sockaddr*>(&servaddr), sizeof(servaddr));
  listen(listenfd, 10);
    
  while(true) {
    connfd = accept(listenfd, nullptr, nullptr);
    handleRequest(connfd);
  }
    
  return 0;
}

use actix_web::{web, App, HttpServer, Responder};

async fn index() -> impl Responder {
  "Hello from Rust!"
}

#[actix_rt::main]
async fn main() -> std::io::Result<()> {
  println!("Starting web server on http://localhost:8080");
  HttpServer::new(|| {
    App::new().route("/", web::get().to(index))
  })
  .bind(("127.0.0.1", 8080))?
  .run()
  .await
}

package main
import (
  "fmt"
  "log"
  "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
  fmt.Fprintf(w, "Hello from Go!")
}

func main() {
  http.HandleFunc("/", handler)
  log.Fatal(http.ListenAndServe(":8080", nil))
}

// hex_to_bin.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>

void digit_to_bin(const char digit) {
  int cp_digit;
  if (digit > 47 && digit < 58) {
    cp_digit = digit - 48;
  } else if (digit > 96 && digit < 103) {
    cp_digit = digit - 87;
  } else {
    perror("Incorrect input");
    exit(0);
  } 

  for (int i = 3; i >= 0; --i) {
    printf("%d", (cp_digit >> i) & 1);
  }
}

void hex_to_bin(const char* hex_str_num) {
  for (int i = 0; i != strlen(hex_str_num); ++i) {
    digit_to_bin(tolower(hex_str_num[i]));
  }
  putchar('\n');
}

void read_line(char* buffer, size_t buffer_size) {
  const char* input = fgets(buffer, buffer_size, stdin);

  if (NULL != input) {
    char* end_ptr = strchr(buffer, '\n');
    if (NULL != end_ptr) {
      *end_ptr = '\0';
    }
  }
}

char* prefix_ignore(char* input) {
  char* result = NULL;
  if (input[0] == '0' && tolower(input[1]) == 'x') {
    result = &input[2];
  }
  return result;
}

int main(void) {
  enum {SIZE = 101};
  char input[SIZE] = {0};
  
  read_line(input, SIZE);
  //puts(input);

  if (strlen(input)) { 
    const char* hex_ptr = prefix_ignore(input);
    if (NULL != hex_ptr) {
      hex_to_bin(prefix_ignore(input));
    } else {
      hex_to_bin(input);
    }
  }

  return 0;
}

# Динамическое создание класса Person
Person = type('Person', (), {'name': 'John'})
john = Person()
print(john.name)

let obj = {};
obj.sayHello = function () {
    console.log("Привет!");
};
obj.sayHello();

class Animal
  def speak
    puts "Р-р!"
  end
end

Animal.class_eval do
  define_method(:roar) { |volume| puts "#{volume} Р-Р-Р!!!" }
end

lion = Animal.new
lion.roar("Громко")

template <typename T>
void process(T value) {
  std::cout << "Обработка типа: " << typeid(value).name() << "\n";
}

process<int>(42); // Обработаем целое число
process<double>(3.14); // Обработаем вещественное число

trait Shape {
  fn area(&self) -> f64;
}

struct Circle(f64);
impl Shape for Circle {
  fn area(&self) -> f64 {
    std::f64::consts::PI * self.0.powi(2)
  }
}

fn print_area(shape: &dyn Shape) {
  println!("Площадь фигуры: {}", shape.area());
}

// Используем circle
let c = Circle(3.0);
print_area(&c);

package main

import "fmt"

type Shaper interface {
  Area() float64
}

type Rectangle struct {
  width, height float64
}

func (r Rectangle) Area() float64 {
  return r.width * r.height
}

func main() {
  r := Rectangle{width: 10, height: 5}
  fmt.Println(r.Area()) // Площадь прямоугольника
}

package main

import (
  "fmt"
  "reflect"
)

type MyStruct struct{}

func (m MyStruct) SayHi() string {
  return "Привет!"
}

func main() {
  myInstance := MyStruct{}
  methodValue := reflect.ValueOf(myInstance).MethodByName("SayHi").Call(nil)[0]
  fmt.Println(methodValue.String())
}

ls -i

find /path/to/directory -inum <номер_inode> -print

stat file_name

kill -l | grep SIGKILL

man 7 signal

ps aux | grep systemd

root       1  0.0  0.0   7880  1804 ?        Ss   Aug11   0:01 /usr/lib/systemd/systemd --switch-root=/run/initramfs/initrd.img
...

pidof systemd

sudo systemctl start <служба>.service

sudo systemctl stop <служба>.service

sudo systemctl reboot

sudo systemctl status <служба>.service

sudo systemctl disable <служба>.service