var requestsTotal = prometheus.NewCounter(prometheus.CounterOpts{
  Name: "http_requests_total",
  Help: "Total number of processed HTTP requests.",
})

var freeMemoryBytes = prometheus.NewGauge(prometheus.GaugeOpts{
  Name: "free_memory_bytes",
  Help: "Amount of available memory in bytes.",
})

var requestDurationSeconds = prometheus.NewHistogramVec(
  prometheus.HistogramOpts{
    Name: "http_request_duration_seconds",
    Help: "HTTP request duration distribution.",
    Buckets: []float64{.005, .01, .025, .05, .1, .25},
  },
  []string{"method"},
)

var requestLatencyMilliseconds = prometheus.NewSummaryVec(
  prometheus.SummaryOpts{
    Name: "http_request_latency_milliseconds",
    Help: "Request processing time summary statistics.",
    Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001}, // percentiles
  },
  []string{"endpoint"},
)

package main
import (
  "net/http"
  "github.com/prometheus/client_golang/prometheus"
  "github.com/prometheus/client_golang/prometheus/promauto"
  "github.com/prometheus/client_golang/prometheus/promhttp"
)

var (
  requestsTotal = promauto.NewCounter(prometheus.CounterOpts{
    Name: "http_requests_total",
    Help: "Total number of processed HTTP requests.",
  })
  requestDurationSeconds = promauto.NewHistogramVec(prometheus.HistogramOpts{
    Name:    "http_request_duration_seconds",
    Help:    "HTTP request duration histogram.",
    Buckets: prometheus.LinearBuckets(0.001, 0.001, 10),
  }, []string{"path"})
)

func handler(w http.ResponseWriter, r *http.Request) {
  defer func() { requestsTotal.Inc() }()
  timer := prometheus.NewTimer(requestDurationSeconds.WithLabelValues(r.URL.Path))
  defer timer.ObserveDuration()
  w.Write([]byte("Hello World"))
}

func main() {
  http.HandleFunc("/", handler)
  http.Handle("/metrics", promhttp.Handler())
  http.ListenAndServe(":8080", nil)
}

package main
import (
  "fmt"
  "log"
  "runtime"
)

func main() {
  var m runtime.MemStats
  runtime.ReadMemStats(&m)
  fmt.Printf("Alloc: %v MiB\n", bToMb(m.Alloc))  // Выделено памяти
  fmt.Printf("Sys: %v MiB\n", bToMb(m.Sys))  // Общая система памяти
  fmt.Printf("NumGC: %d\n", m.NumGC)  // Число запусков GC
  fmt.Printf("PauseTotalNs: %v ms\n", nsToMs(m.PauseTotalNs))  // Всего пауза GC
  log.Println(runtime.NumGoroutine())  // Текущие активные goroutines
}

// Вспомогательные функции преобразования байтов и наносекунд
func bToMb(b uint64) float64 { return float64(b) / 1024 / 1024 }
func nsToMs(ns int64) float64 { return float64(ns) / 1_000_000 }

package main
import (
  "log"
  "net/http"
  _ "net/http/pprof"
)

func main() {
  http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello World!"))
  })
  log.Println("Starting server at :8080")
  err := http.ListenAndServe(":8080", nil)
  if err != nil {
    log.Fatal(err)
  }
}

// Запись профиля ЦПУ
package main
import (
  "log"
  "os"
  "runtime/pprof"
  "time"
)

func main() {
  f, err := os.Create("cpu.pprof")
  if err != nil {
    log.Fatal(err)
  }
  defer f.Close()

  // Начинаем запись профиля ЦПУ
  pprof.StartCPUProfile(f)
  defer pprof.StopCPUProfile()

  time.Sleep(time.Second * 10) // Моделируем длительную операцию
}

type Animal struct {
  Name string
  Sound string
}

type Dog struct {
  Animal
  Breed string
}

func NewDog(name, breed string) *Dog {
  return &Dog{
    Animal: Animal{Name: name, Sound: "Woof"},
    Breed:  breed,
  }
}

func main() {
  dog := NewDog("Rex", "Labrador")
  fmt.Printf("%s is a %s and says %s\n", dog.Name, dog.Breed, dog.Sound)
}

class Rectangle:
  def __init__(self, width, height):
    self._width = width
    self._height = height

  @property
  def area(self):
    return self._width * self._height

class Square(Rectangle):
  def __init__(self, side_length):
    super().__init__(side_length, side_length)
    
  # Нарушение контракта родителя, изменение ширины меняет высоту
  def set_width(self, value):
    self._width = value
    self._height = value

// Пример интерфейса Sorter
type Sorter interface {
  Len() int
  Less(i, j int) bool
  Swap(i, j int)
}

// Реализация сортировки массива чисел
type IntArray []int

func (a IntArray) Len() int           { return len(a) }
func (a IntArray) Less(i, j int) bool { return a[i] < a[j] }
func (a IntArray) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

// Обобщённая функция сортировки
func Sort(data Sorter) {
  for i := range data {
    for j := i + 1; j < data.Len(); j++ {
      if data.Less(j, i) {
        data.Swap(i, j)
      }
    }
  }
}

// Пример с использованием дженериков (начиная с Go 1.18)
func Min[T any](values ...T) T {
  var min T
  first := true
  for _, v := range values {
    if first || less(v, min) {
      min = v
      first = false
    }
  }
  return min
}

func less[T comparable](a, b T) bool {
  return a < b
}

package main
import (
  "fmt"
  "sync"
)

// Функция мапа, применяемая к каждому элементу
func mapper(chunks [][]int) chan int {
  outCh := make(chan int)
  go func() {
    for _, chunk := range chunks {
      sum := 0
      for _, val := range chunk {
        sum += val
      }
      outCh <- sum
    }
    close(outCh)
  }()
  return outCh
}

// Функция reduce, собирающая промежуточные суммы
func reducer(sumChans []chan int) int {
  totalSum := 0
  wg := sync.WaitGroup{}
  for _, ch := range sumChans {
    wg.Add(1)
    go func(c chan int) {
      for s := range c {
        totalSum += s
      }
      wg.Done()
    }(ch)
  }
  wg.Wait()
  return totalSum
}

func main() {
  numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
  chunkSize := 2
  chunks := make([][]int, 0)

  // Разбиение исходных данных на чанки
  for i := 0; i < len(numbers); i += chunkSize {
    end := i + chunkSize
    if end > len(numbers) {
      end = len(numbers)
    }
    chunks = append(chunks, numbers[i:end])
  }

  // Создаем каналы для каждой порции данных
  mapChannels := make([]chan int, len(chunks))
  for i := range chunks {
    mapChannels[i] = mapper([][]int{chunks[i]})
  }

  // Собираем итоги
  result := reducer(mapChannels)
  fmt.Println(result) // Выведет 55
}

//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их библиотек.