Сравнительный анализ в Golang:

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

В пакете go testing есть средство тестирования производительности, которое можно использовать для оценки производительности вашего кода Go. Тесты размещаются внутри _test.go файлов и следуют правилам своих аналогов.

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

func Fact(n int) int{
   if  n > 0{
      return n * Fact(n-1)
   }else {
      return 1
   }
}

_test.go содержат контрольные показатели и ограничения для тестовых аналогов. В приведенной выше программе мы будем измерять скорость вычислений факториала числа 10.

Напишем эталонную функцию.

package main

import "testing"

func BenchmarkFact(b *testing.B) {
   // run the Fib function b.N times
   for n := 0; n < b.N; n++ {
      Fact(10)
   }
}

Написание бенчмарка совместно используемой инфраструктуры из пакета testing. Функция тестирования начинается с Benchmark и запускается несколько раз путем «тестирования» пакета на основе значения b.N. Значение увеличивается каждый раз, когда бегун удовлетворен стабильностью теста.

Теперь запустите тестовую функцию, используя

go test -bench=.

Команда test говорит, что мы передаем параметр -bench, чтобы пройти тест, передав регулярное выражение, которое соответствует всем. Регулярное выражение должно быть допустимым, иначе передача только -bench вызовет синтаксическую ошибку.

Из результатов первая строка дает среднее время выполнения тестируемой функции для конечного значения b.N итераций. Для приведенной выше контрольной функции он выполняет Fact(10) за 39,6 наносекунд в моей локальной системе. Вторая строка, PASS, исходит из тестовой части драйвера test. В третьей строке содержится информация о пути к файлу и времени, затраченном на выполнение.

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

package main

import "testing"

func benchmarkFact(i int, b *testing.B) {
   // run the Fib function b.N times
   for n := 0; n < b.N; n++ {
      Fact(10)
   }
}

func BenchmarkFact1(b *testing.B)  { benchmarkFact(1, b) }
func BenchmarkFact5(b *testing.B)  { benchmarkFact(5, b) }
func BenchmarkFact10(b *testing.B)  { benchmarkFact(10, b) }
func BenchmarkFact15(b *testing.B)  { benchmarkFact(15, b) }
func BenchmarkFact20(b *testing.B)  { benchmarkFact(20, b) }

Вывод:

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

Безопасность:

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

Есть несколько факторов, которые необходимо учитывать, чтобы решить, является ли язык безопасным или небезопасным, но их можно свести к двум факторам:

  1. Безопасность типов: способность языка предотвращать различные ошибки, связанные с типами.
  2. Безопасность памяти.Способность языка предотвращать различные ошибки, связанные с памятью, такие как выход за пределы памяти, свободное после использования и т. д.

Go — язык со строгими и статическими типами. Поэтому можно с уверенностью сказать, что тип никогда не будет неправильно истолкован. В Go нет арифметики указателей, хотя в нем есть «nil», который является своего рода нулевой ссылкой.

В этом смысле утверждения типа в Go работают на пользу языку, например, эквивалент «void*» в Go-«Interface{}» приводится более безопасным способом с использованием type- утверждений, так что это не просто приведет к сбою и позволит более безопасно тестировать типы или переключать типы. Итак, мы можем сказать, что Go является типобезопасным.

Объем памяти:

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

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

package main

import (
   "runtime"
   "fmt"
   "time"
)

func main() {
   PrintMemUsage()

   var overall [][]int
   for i := 0; i<4; i++ {
      a := make([]int, 0, 999999)
      overall = append(overall, a)
      PrintMemUsage()
      time.Sleep(time.Second)
   }
   overall = nil
   PrintMemUsage()

   runtime.GC()
   PrintMemUsage()
}

func PrintMemUsage() {
   var m runtime.MemStats
   runtime.ReadMemStats(&m)
   fmt.Printf("Alloc = %v MiB", bToMb(m.Alloc))
   fmt.Printf("\tTotalAlloc = %v MiB", bToMb(m.TotalAlloc))
   fmt.Printf("\tSys = %v MiB", bToMb(m.Sys))
   fmt.Printf("\tNumGC = %v\n", m.NumGC)
}

func bToMb(b uint64) uint64 {
   return b / 1024 / 1024
}

Это память, выделенная для переменной «всего» за 4 итерации цикла for.

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

Простота использования:

Если вы знакомы с каким-либо языком программирования, Golang легко освоить благодаря простому синтаксису. Гораздо быстрее получить практический опыт работы с Golang с помощью Tour of Go и разработать свою первую программу за пару дней. Go — это, в частности, язык программирования системного уровня для высокомасштабируемых сетевых серверов и распределенной системной архитектуры. Go в основном решает проблемы с медленным выполнением и компиляцией программ, проблемы с версиями и зависимости, которыми трудно управлять.

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

Следуя за Effective Go и возясь со стандартной библиотекой, набором веб-инструментов, таким как Gorilla и Go, вы станете достойным разработчиком Golang.

Причина использования Golang:

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

Основные причины использования Golang следующие:

  • Golang обеспечивает простое параллельное программирование с горутинами и каналами.
  • Веб-сайт Go предоставляет отличные ресурсы для начала.
  • Go имеет опытную стандартную библиотеку, которая поддерживает аспекты, связанные с сетевыми протоколами, такими как HTTP-клиент и сервер, шифрование, сжатие, отправка электронной почты и т. д.
  • Go эффективен. Это потрясающий опыт для пользователей, перешедших с Python, Ruby или Node.js, поскольку go значительно увеличивает количество одновременных запросов, которые может обработать сервер.
  • Дать определение формата кода — огромная проблема. Go решает эту проблему, определяя канонический формат для кода, написанного на Go. Инструмент gofmt переформатирует ваш код.
  • Go предоставляет стандартизированную среду тестирования для выполнения параллельного тестирования и сравнительного анализа, а также имеет несколько наборов инструментов для выполнения тестирования между сетевыми клиентами и серверами.

Авторы:
Ибрагим Мохаммад @github @linkedin
Нитеш Ярра @github @linkedin
Шри Сурадж Булусу@github @linkedin