Как я оптимизировала фронт на 40% и никто не заметил ...

Ну тут вопрос в том оптимизировали на 40% размер бандла вк или внутренней админки. В каком-нибудь вк в котором страницы по 20 мегабайт по несколько минут грузятся это было бы классным достижением, в админке - как будто бесполезно. Но строчку напишут все потому что не хотят вылететь по автофильтрам

Почему в споре iOS vs Android никто не говорит о главном

"Почему в споре iOS vs Android никто не говорит о главном?"
О Аврора ОС? (простите)

Go рухнул с 7 на 16 место в TIOBE: пора ли российским компаниям пересмотреть технологический стек?

Потому что в США не было такого бума новых продуктов у крупных компаний, были в основном стартапы, которые традиционно на джс/пхп/etc.

Про Китай не знаю много, но я бы не сказал что там не так потому что как минимум bytedance активно использует go и развивает инфраструктуру вокруг go.

Go рухнул с 7 на 16 место в TIOBE: пора ли российским компаниям пересмотреть технологический стек?

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

Go рухнул с 7 на 16 место в TIOBE: пора ли российским компаниям пересмотреть технологический стек?

Вся статья выглядит как нытье старого джависта котого заставили выучить го

Подписка Claude больше не работает в сторонних редакторах кода — разработчики в ярости

Потому что терминальный клиент Claude Code реализует ACP и подразумевает интеграцию по этому протоколу с любой IDE которая приложит к этому усилия, как например Zed

Чистим main.go: предсказуемый старт и надежный Graceful Shutdown

Ух ты, мы с вами буквально одну и ту же проблему решили, только я нигде не публиковал кроме корп репозитория. Чуть проще:

package graceful

import (
	"context"
	"time"

	"go.uber.org/multierr"
)

type (
	GroupConfiguration struct {
		Timeout time.Duration `name:"TIMEOUT" default:"30s"`
	}

	TimeoutOption time.Duration

	Group struct {
		configuration *GroupConfiguration
		ctx           context.Context
		cancel        context.CancelFunc
		errors        chan error
		closers       []closer
		wait          uint64
	}

	Resource[T_resource any] struct {
		group    *Group
		resource *T_resource
	}

	Task[T_resource any] func(context context.Context, resource *T_resource) error

	closer struct {
		resource any
		task     any
		wrapper  func(ctx context.Context, resource, task any, errors chan error)
	}
)

func New(ctx context.Context, configuration *GroupConfiguration) *Group {
	ctx, cancel := context.WithCancel(ctx)

	return &Group{
		configuration: configuration,
		ctx:           ctx,
		cancel:        cancel,
		errors:        make(chan error, 1),
	}
}

func WithOptions(ctx context.Context, options ...any) *Group {
	configuration := &GroupConfiguration{
		Timeout: 30 * time.Second,
	}

	for i := range options {
		switch typed := options[i].(type) {
		case TimeoutOption:
			configuration.Timeout = time.Duration(typed)
		}
	}

	ctx, cancel := context.WithCancel(ctx)

	return &Group{
		configuration: configuration,
		ctx:           ctx,
		cancel:        cancel,
		errors:        make(chan error, 1),
	}
}

func (group *Group) Context() context.Context {
	return group.ctx
}

func (group *Group) Wait() error {
	<-group.ctx.Done()

	ctx, cancel := context.Background(), context.CancelFunc(nil)

	if group.configuration.Timeout > 0 {
		ctx, cancel = context.WithTimeout(ctx, group.configuration.Timeout)
	}

	for _, closer := range group.closers {
		go closer.wrapper(ctx, closer.resource, closer.task, group.errors)
	}

	errors := []error(nil)

cycle:
	for group.wait > 0 {
		select {
		case <-ctx.Done():
			break cycle
		case err := <-group.errors:
			if err != nil {
				errors = append(errors, err)
			}
		}

		group.wait -= 1
	}

	if cancel != nil {
		cancel()
	}

	return multierr.Combine(errors...)
}

func AddResource[T_resource any](group *Group, resource *T_resource) Resource[T_resource] {
	return Resource[T_resource]{
		group:    group,
		resource: resource,
	}
}

func (resource Resource[T_resource]) OnStart(task Task[T_resource]) Resource[T_resource] {
	resource.group.wait += 1

	go func(resource Resource[T_resource], task Task[T_resource]) {
		err := task(resource.group.ctx, resource.resource)

		resource.group.cancel()
		resource.group.errors <- err
	}(resource, task)

	return resource
}

func (resource Resource[T_resource]) OnClose(task Task[T_resource]) Resource[T_resource] {
	resource.group.wait += 1

	wrapper := func(ctx context.Context, resource, task any, errors chan error) {
		errors <- task.(Task[T_resource])(ctx, resource.(*T_resource))
	}

	resource.group.closers = append(resource.group.closers, closer{
		resource: resource.resource,
		task:     task,
		wrapper:  wrapper,
	})

	return resource
}

package notifier

import (
	"context"
	"errors"
	"fmt"
	"os"
	"os/signal"
)

type (
	Notifier struct {
		signals  []os.Signal
		receiver chan os.Signal
	}
)

var (
	ErrSignalReceived = errors.New("signal received")
)

func New(signals []os.Signal) *Notifier {
	return &Notifier{
		signals:  signals,
		receiver: make(chan os.Signal, 1),
	}
}

func OnStart(ctx context.Context, notifier *Notifier) (err error) {
	signal.Notify(notifier.receiver, notifier.signals...)

	select {
	case <-ctx.Done():
		return nil
	case signal := <-notifier.receiver:
		return fmt.Errorf("%w: %s", ErrSignalReceived, signal.String())
	}
}

func OnClose(ctx context.Context, notifier *Notifier) (err error) {
	signal.Stop(notifier.receiver)
	return nil
}

Очень сильно упростило жизнь менее опытных коллег и меня когда за этими менее опытными коллегами надо переделать graceful shutdown.

Почему в Rust всё правильно

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

Так он и должен быть допускаемым значением для всех ссылочных типов.
Null - это 0. Вы сейчас говорите а давайте заведем специальный тип чисел который может быть чем угодно кроме нуля. Это некорректно, это логическое ограничение а не техническое. И обрабатываться оно должно как часть логики а не техники. Это мы опять решаем софт проблему хард методом.

Почему в Rust всё правильно

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

Почему в Rust всё правильно

Согласен по всем пунктам кроме borrow checker'а, null-безопасности и асинхроннсти:

fn main() {
    let s = String::from("hello"); 

    make_some_processing(s);
    // Не скомпилируется, так как функция make_some_processing
    // забрала владение над s, и здесь s уже недоступен
    println!("Processed: {s}");
} 

fn make_some_processing(some_string: String) {
    println!("{some_string}");
}

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

Про null это вообще бред, вот у нас есть некий класс который может быть нулл. В расте для такого случая предполагается сделать указатель на этот класс опциональным и проверять на None. Но если всё равно проверять на None в чём проблема блин проверить на null? Это буквально тот же самый if !class.is_none только if class != null. Изобрели костыль и ходят радостные.

Ну и про асинхронность да она есть и довольно удобная но это всё ещё заражающая асинхронность когда приходится в итоге делать асинхронным ВЕСЬ код. А ещё если открыть tfb внезапно обнаружится что самая быстрая асинхронность в этом вашем расте внезапно у библиотеки may, то есть буквально той библиотеки которая обходит все встроенные механизмы асинхронности.

Роскомнадзор подтвердил блокировку платформы Roblox в РФ, что дальше?

Так и? Школота виновата что взрослые не уследили за начальством? Где смеятся?

Go: логирование

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

Разработчик (Mobile Developer) и программист Алексей...

Автору бы удалить и не позорится...
Во первых вот это "вы все тупые если не знаете как это работает в андроиде". Мы как бы и не обязаны знать как это работает.
Во вторых чел часто ссылается на то, что модерация гугла что-то не пропустит. Но мы живем в мире где а) люди будут качать это из рустора б) если в законе сказано что надо предустановить - гугл и производители это предустанавливают вне зависимости от модерации.
Ну и в третьих - то что что-то делают все не означает что это должен делать макс. Обьективно - к максу повышеные ожидания так как его продвигает и требует к установке государство которому мы тут все по каким-то своим причинам не очень доверяем. То что позволено вотсапу или тележке не позволено максу просто потому, что если ваши данные похищает заокеанский тщ майор - так где я, а где он (за океаном). Но вот если данные осваивает отечественный - обычно жди беды.

Go по-прежнему полон проблем

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

Go по-прежнему полон проблем

"Область видимости переменной err вводит в заблуждение" или троллинг №1

Чувак показывает следующие примеры:

if err := foo(); err != nil {
   return err
}

bar, err := foo()
if err != nil {
  return err
}
if err = foo2(); err != nil {
  return err
}

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

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

Во первых переиспользование переменных существует буквально во всех языках и служит для удобства и экономии памяти. Даже в условном javascript у нас есть throw который может выкинуть только одну ошибку, если их две то придётся по€6@ться и обьединить их в одну.

Во вторых если в втором if-блоке сменить = на := то есть (внезапно) оператор присваивания сменить на (внезапно) оператор создания эта переменная-ошибка будет существовать только внутри блока и никак не затронет переменную-ошибку областью видимости выше.

В третьих создавать переменные в if и for блоках - плохой тон в продакшн коде, код должен выглядеть так:

bar, err := foo()
if err != nil {
  return err
}
err = foo2()
if err != nil {
  return err
}

или так

bar, err1 := foo()
err2 := foo2()
if err1 != nil || err2 != nil {
  return errors.Join(err1, err2)
}

в зависимости от бизнес-требований и жизнь становится значительно проще и понятнее.

"Два вида nil" или чувак никогда не ходил на собеседование по go

Чувак пытается сравнить интерфейс и указатель на структуру которая реализует этот интерфейс и недоумевает почему же они не равны.

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

type (
  Interface[T any] struct {
    type *Type // internal T representation
    data *T
  }
  Type struct {
    table *VirtualTable
  }
)

Таким образом когда чувак присвоил переменной типа интерфейс nil-указатель на структуру - он заполнил как минимум одно поле интерфейса а именно type и очевидно после этого интерфейс не может считаться пустым.
Также очевидно что пока в интерфейсе и type и data равны nil, то и весь интерфейс равен nil.

"Отсутствие портируемости" или смотрим узко

Тут чел решил наехать на build-тэги в комментарии в начале файла типа это программирование в закрытой комнате.
Тут можно поспорить сразу с двух сторон:
Во первых практика показывает что go, где есть fyne и ebitengine, легче использовать для мобильных приложений, чем например rust, где есть только slint который ещё и работает плохо, где всё сделано примерно как хочет автор.

Во вторых кроме build-тэгов есть множество других тэгов таких как //go:linkname ... или //go:embed ... и если уже мы говорим о вопросах к системе тэгов, то её проблема гораздо больше чем то что build-тэги вешаются только на файлы а не на конкретные функции.

Как я уже сказал я сам имею вопросы к go и мета-программирование, а вернее его отсутствие один из основных.

"append без определения владения" или троллинг №2

Чувак приходит к нам с этим

package main
import "fmt"
func foo(a []string) {
    a = append(a, "NIGHTMARE")
}
func main() {
    a := []string{"hello", "world", "!"}
    foo(a[:1])
    fmt.Println(a)
}

и спрашивает, а как так эта программа печатает "hello NIGHTMARE !"?
Это в мире где буквально каждое собеседование по go начинается с вопроса "Что такое слайс?". Я отношу это к троллингу, так как очевидно что автор не может не знать как работает слайс, а также по словам "определение владения" которые нам известны из мира rust.

Пояснение для несведующих: слайс на самом деле это

type Slice[T any] struct {
  data     *T
  length   int
  capacity int
}

Знания этого факта достаточно чтобы понять что когда мы передаем в функцию слайс - мы на самом деле передаем копию всех этих полей и в том числе копию указателя на массив, куда в процессе append записываются значения пока length меньше capacity.

Да в расте напечатать "hello Nightmare !" не получилось бы. Но в расте с его концепцией владения такой код впринципе невозможен: ниже прикладываю листинг который вы можете попробовать запустить и убедится что это не компилируется.

fn foo(mut a: Vec<&str>) {
    a.push("NIGHTMARE");
}
fn main() {
    let mut a = vec!["Hello", "world", "!"];
    foo(a);
    println!("{:?}", a);
}

Раст нас заставляет сделать копию вектора (тот же слайс только в профиль)

fn foo(mut a: Vec<&str>) {
    a.push("NIGHTMARE");
}
fn main() {
    let mut a = vec!["Hello", "world", "!"];
    foo(a.clone());
    println!("{:?}", a);
}

что возможно и очень безопасно, но совершенно точно тратит больше ресурсов системы и ограничивает программиста в его экспрессии.

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

Я устал писать и считаю что доказав безосновательность 4 из 8 претензий автора статистически доказываю безосновательность всей статьи, но если вдруг вам необходимо продолжение - буду ожидать от 5 тысяч рублей по СБП по номеру [phone] на Цифра или Озон банк с комментарием "продолжаем спорить".

Также буду благодарен приглашениям на интересные вакансии. Интересные - это крипто, игровые или инфраструктурные проекты с вилкой не ниже $4000 и допустимой удалённой работой не с территории РФ.

Go по-прежнему полон проблем

Что конкретно вас интересует?

Go по-прежнему полон проблем

У кого-то ещё в процессе чтения было ощущение "Не, ну это точно троллиг"? Я не знаю кто этот чел чтобы его статьи переводить и размещать здесь, я сам имею к go много вопросов, но это все выглядит будто чувак тотально не разобрался

В сервисе «2ГИС» появился детский профиль с уведомлениями о передвижении и историей маршрутов

Будь я педофилом я бы прямо сейчас пошел куда-нибудь в даркнет покупать сливы этих маршрутов

В WhatsApp ответили на решение о блокировке звонков для российских пользователей

Звонили мне как-то в WhatsApp. Сказали что если в военкомат не приду то меня в розыск обьявят. Точно мошенники.

Барьеры памяти «Golang»

Какой ад, хорошо что на практике об это не нужно думать