Покажи HN: Rev-dep – 20 пъти по-бързо алтернативно изграждане на knip.dev в Go

Скритият данък върху всеки разрастващ се софтуерен екип

Всеки софтуерен проект, който оцелява достатъчно дълго, в крайна сметка се сблъсква със същата тиха криза: кодовата база започва да расте по-бързо, отколкото екипът може да я разбере. Функции, които никой не извиква, експорти, които са създадени за функция, която беше доставена през 2022 г. и беше тихо отхвърлена, компоненти, които живеят на диск, но никога не достигат до браузър. Това не е помия - това е физика. Екипите се движат бързо, изискванията се променят и ентропията е безмилостна. Въпросът не е дали вашата кодова база има мъртъв код. Въпросът е колко ви струва в момента.

Според проучване на инженерния екип на Google за производителност, разработчиците прекарват средно 42% от времето си за кодиране в четене и разбиране на съществуващ код, вместо да пишат нова функционалност. Когато този съществуващ код включва хиляди редове, които вече не служат за никаква цел, този процент се изкривява още повече. За екип от десет инженери, това на практика са четирима служители на пълен работен ден, които не правят нищо продуктивно – не защото са мързеливи, а защото техните инструменти не са в крак със скоростта, с която софтуерът остарява.

Ето защо нова вълна от инструменти за разработчици, изградени на системни езици като Go и Rust, предизвиква истинско вълнение в инженерните среди. Инструменти като Rev-dep — анализатор на обратна зависимост, който твърди, че работи 20 пъти по-бързо от популярния базиран на JavaScript knip.dev — представляват повече от просто постепенно подобрение. Те сигнализират за фундаментално преосмисляне на това как инструментираме самия процес на разработка.

Какво всъщност прави анализът на обратната зависимост

Преди да разберете защо скоростта има толкова голямо значение, е добре да разберете какво всъщност правят инструментите за анализ на зависимостите. В проект на JavaScript или TypeScript всеки файл се импортира от други файлове. Всяка функция, клас или константа, която се експортира от модул, създава потенциална зависимост - нещо, на което други части от кодовата база могат да разчитат. „Обратният“ анализ на зависимостта обръща тази перспектива: вместо да пита „от какво зависи този модул“, той пита „какво зависи от този модул?“

Ако отговорът на този втори въпрос е „нищо“, вие сте открили мъртъв код. Износ, който нищо не внася, е разхищение. Функция, която нищо не извиква, е технически дълг с месечен лихвен процент. Инструментите за обратна зависимост систематично обхождат цялата ви графика на проекта, картографират всяка връзка между модулите и извеждат на повърхността възлите, които нямат входящи връзки. Резултатът е прецизен одит на всичко във вашата кодова база, което може безопасно да бъде премахнато.

Knip.dev прави това добре за JavaScript и TypeScript проекти и е широко уважаван в общността. Но той е написан на JavaScript, което означава, че работи на Node.js, което означава, че наследява всички ограничения на производителността на Node с една нишка, когато извършва широкомащабно обхождане на файловата система и анализ на символи. За проект с 500 файла това е добре. За проект с 50 000 файла - видът monorepo, който захранва истински корпоративни SaaS продукти - анализът може да отнеме минути. И минутите, при ритъма, с който работят съвременните CI/CD тръбопроводи, са прекъсване на сделката.

Защо Go променя изчислението

Go е проектиран от самото начало за точно вида работа, който изисква анализът на зависимостите: бърз вход/изход на файлове, отлични примитиви за паралелност и минимално време за изпълнение. Когато Node.js обработва една задача наведнъж в една нишка и разчита на обратни извиквания и обещава да фалшифицира паралелизъм, Go може да създаде хиляди goroutines, които наистина се изпълняват паралелно във всички налични CPU ядра. За задача, която включва четене на стотици файлове, анализиране на техните AST и изграждане на графика на символни връзки, тази архитектурна разлика се превръща директно в производителност на стенен часовник.

20-кратното ускоряване, заявено от Rev-dep, не е магия — това се случва, когато съпоставите правилния език с правилния проблем. Компилираният характер на Go също означава липса на наказание за загряване на JIT. От студения старт до пълния анализ двоичният файл на Go работи с почти върхова производителност. Практическото значение е, че анализът, който отне 90 секунди в инструмент, базиран на възел, може да завърши за по-малко от 5 секунди в добре внедрен еквивалент на Go. Това е разликата между проверка, която разработчиците пропускат, защото „отнема цяла вечност“, и такава, която се изпълнява при всеки комит, без никой да забележи излишните разходи.

„Най-добрият инструмент за разработчици е този, който се измъква от пътя. Ако вашият пакет за анализ добави три минути към всеки конвейер на CI, разработчиците ще намерят начини да го пропуснат. Скоростта не е нещо хубаво – тя е предпоставка за приемане.“

Бизнесът за хигиена на кодовата база

Мъртвият код не е само естетически проблем на разработчиците — той има конкретни бизнес последици, които се увеличават с времето. Помислете какво всъщност струва на организациите раздутите кодови бази:

• По-дълги времена за изграждане, които забавят тръбопроводите за внедряване и намаляват броя на изданията, които екипът може безопасно да изпраща на седмица
• По-голямо когнитивно натоварване за инженерите, които се включват в борда, които трябва да прекарат седмици в разграничаване на активните модели от изоставените
• Увеличени размери на пакети, които влошават производителността на приложенията, особено в уеб приложения, където всеки килобайт влияе върху времето за зареждане и процента на реализация
• Разширяване на повърхността на сигурността — мъртъв код, който все още съдържа зависимости, все още е вектор за уязвимости в тези пакети
• Раздуване на тестовия пакет, където тестовете за премахната функционалност продължават да се изпълняват, отнемат CI минути и понякога се провалят по объркващи начини
• Фалшиви сигнали за сложност, които правят архитектурните решения по-трудни, защото не е ясно кое е носещо и кое е рудиментарно

Проучване от 2023 г. на групата DevOps Research and Assessment (DORA) установи, че екипи със силни практики за качество на кода — включително редовно премахване на мъртъв код — изпращат 2,4 пъти по-често и имат 7 пъти по-нисък процент неуспешни промени от екипите, които позволяват натрупването на технически дългове. Корелацията не е случайна. Чистите кодови бази са по-лесни за разсъждение, по-лесни за тестване и по-лесни за безопасна промяна.

За фирми, които изграждат платформи като Mewayz — която захранва 138 000 потребители в 207 отделни бизнес модула, вариращи от CRM и заплати до управление на автопарк и инструменти за свързване в биография — здравето на кодовата база има многократни залози. Когато вашата платформа обхваща толкова много функционални домейни, интеграционната повърхност между модулите е огромна. Неизползваните експорти в основен модул могат да създадат фалшиви очаквания за зависими модули, да задействат ненужни повторни изобразявания в слоя на потребителския интерфейс и да усложнят графиката на зависимостите по начини, които правят бъдещите промени рисковани.

Интегриране на анализа на зависимостите в съвременни работни потоци за разработка

Истинската сила на бързите инструменти като Rev-dep не е еднократното почистване, което позволява – това е способността да изпълнявате непрекъснат анализ като част от вашия нормален цикъл на разработка. Когато сканирането на мъртъв код отнеме 4 секунди вместо 4 минути, можете да го добавите към своите куки за предварително ангажиране. Когато отнеме 4 секунди вместо 4 минути, вашият CI тръбопровод може да провали заявка за изтегляне, която въвежда нови неизползвани експортирания, вместо да ги остави да се натрупват тихо.

Това преминаване от „събитие за тримесечно почистване“ към „непрекъснат контрол на качеството“ е аналогично на това, което се случи, когато линтерите станаха достатъчно бързи, за да работят при всяко натискане на клавиш в IDE. Преди ESLint да работи в реално време, стилът на кода беше наложен чрез периодични прегледи на кода. След това стана амбиент – част от обратната връзка, която разработчиците изпитваха, докато пишат код, а не след това. Бързият анализ на зависимостите може да създаде същия натиск върху качеството на околната среда около мъртъв код.

Настройването на този работен процес обикновено включва три компонента:

1. Базов анализ: Стартирайте инструмента срещу текущата си кодова база, за да разберете мащаба на съществуващия мъртъв код. Не се опитвайте да поправите всичко наведнъж — сортиране по модул и приоритизиране по риск.
2. Прилагане на CI: Добавете анализа към своя конвейер с праг — неуспешно при всички нововъведени неизползвани експорти, но не и при съществуващи, докато не ги изчистите.
3. Планирани спринтове за почистване: Използвайте резултата от инструмента, за да насочвате редовната работа по почистване, като проследявате броя на мъртвите кодове като показател за здравето на екипа във времето.

Какво сигнализира Go Tooling Renaissance за създателите на SaaS

Rev-dep е част от по-широк модел в инструментите за разработчици: във всяка категория се появяват високопроизводителни алтернативи на установените инструменти на JavaScript, изградени в Go или Rust. Biome замени ESLint и Prettier за много отбори. Turbopack и Rspack изяждат обяда на Webpack. Bun предизвиква самия Node.js. Общата нишка е, че тези инструменти не само предлагат постепенно подобрение – те предлагат подобрения на стъпаловидни функции, които променят това, което е практично.

За SaaS компаниите, които изграждат сложни, многомодулни продукти, този инструментален ренесанс има пряко отражение върху скоростта на инженеринга. 207-модулната архитектура на Mewayz — обхващаща всичко от HR и заплати до системи за резервации и табла за анализ — представлява точно онзи вид голяма, взаимосвързана кодова база, където бързият и точен анализ на зависимостите става оперативно критичен. Когато една промяна в споделен помощен модул може теоретично да се разпространи през десетки функционални модули, почти мигновената видимост в действителната графика на зависимостите не е просто удобна – това е вид инфраструктура, която предотвратява скъпи производствени инциденти.

Възможността да се отговори „какво всъщност използва тази функция“ за по-малко от пет секунди, вместо за пет минути, променя начина, по който инженерите вземат решения. Това намалява разходите за разследване, което означава, че инженерите проучват по-често, което означава, че вземат по-добри решения. Това е общата възвръщаемост на инвестицията в бързи инструменти, която често се пренебрегва, когато организациите мислят за разходите за производителност на разработчиците.

Превръщане на премахването на мъртъв код в част от вашата инженерна култура

Технологията сама по себе си не изгражда чисти кодови бази – културата го прави. Инструменти като Rev-dep предоставят възможността, но превръщането на тази възможност в последователна практика изисква организационен ангажимент. Най-ефективните екипи третират показателите за мъртъв код по същия начин, по който третират покритието на теста: като видим, проследяван индикатор за здравето на кодовата база, който се преглежда на инженерни срещи и се взема под внимание при планирането на спринта.

Някои специфични културни практики, които работят добре, включват определяне на „дни за изтриване на код“ — периодични събития, при които изричната цел е да се премахне кодът, вместо да се добави. Netlify прочуто геймифицира това, като стартира класации, проследяващи изтрити нетни линии. Stripe са писали публично за тяхната практика да третират изтриването на код като първокласен инженерен принос, равен по стойност на работата по функциите. Необходимата промяна в мисленето е признаването, че най-добрият код е код, който не съществува: всеки ред, който не напишете, е ред, който никога не трябва да поддържате, тествате, отстранявате грешки или обяснявате на нов нает.

За продуктовите компании, управляващи сложни бизнес операции, паралелът извън инженерството е също толкова поучителен. Същата дисциплина, която прави кодовите бази по-здрави – редовни одити, ясна собственост, премахване на неща, които никой не използва – прави и бизнес процесите по-здравословни. Платформи като Mewayz са създадени точно, за да осигурят на бизнеса този вид оперативна яснота: единен поглед върху това кои инструменти се използват, кои работни потоци генерират стойност и къде се натрупва организационна тежест. Независимо дали извършвате одит на експортиране на неизползван софтуер или неизползвани бизнес процеси, основната дисциплина е идентична.

Инструментите стават по-бързи, веригите за обратна връзка стават по-тесни и екипите, които инвестират в инфраструктура за хигиена на кодовата база днес, изграждат комбинирано предимство, което ще носи дивиденти с години. Rev-dep и неговата кохорта от Go-захранвани инструменти за разработчици не са просто интересни показатели — те са инфраструктурният слой, който прави възможна устойчивата скорост на софтуера. И в свят, в който скоростта на итерация е основното конкурентно предимство за софтуерния бизнес, това не е периферна грижа. Това е цялата игра.

Често задавани въпроси

Какво прави Rev-dep по-бърз от knip.dev?

Rev-dep е изграден в Go, компилиран системен език, оптимизиран за едновременност и необработена скорост на изпълнение, докато knip.dev работи на Node.js. Тази архитектурна разлика позволява на Rev-dep да анализира графики на зависимости и да открива мъртъв код до 20 пъти по-бързо. За големи монорепо или сложни кодови бази — като архитектурата с 207 модула, захранваща бизнес операционната система на Mewayz на app.mewayz.com — тази разлика в производителността се превръща в спестено реално време при всяко изпълнение на CI.

Колко мъртъв код натрупва един типичен разрастващ се проект?

Проучвания и анекдотични доклади от инженерни екипи показват, че зрелите кодови бази могат да носят от 10% до 35% неизползван или недостъпен код. Проблемът се задълбочава с мащабирането на екипите – функциите се отхвърлят, API се променят и модулите се изоставят без почистване. Платформи като Mewayz, която консолидира над 207 бизнес модула в една операционна система за $19/месец, разчитат в голяма степен на систематично откриване на мъртъв код, за да поддържат кодовата база стройна и поддържана.

Rev-dep подходящ ли е за екипи, които не използват JavaScript или TypeScript?

В момента Rev-dep е фокусиран върху екосистемите на JavaScript и TypeScript, което го прави директна алтернатива на knip.dev за тези среди. Поддръжката за допълнителни езици може да се разшири с развитието на проекта. Ако вашият екип изгражда уеб-базирани продукти или инструменти за SaaS — подобно на начина, по който Mewayz доставя пълната си бизнес операционна система на app.mewayz.com — и вашият стек е натоварен с JS/TS, Rev-dep си заслужава да бъде оценен като част от вашата верига инструменти за разработчици днес.

Мога ли да интегрирам Rev-dep в моя съществуващ CI/CD канал?

Да. Rev-dep е проектиран като CLI инструмент, което го прави лесен за пускане във всеки CI/CD тръбопровод заедно с вашите съществуващи стъпки за линтинг и тестване. Неговото предимство в скоростта е особено ценно при автоматизирани конвейери, където по-бързите вериги за обратна връзка намаляват времето за изчакване на разработчиците. Независимо дали управлявате щадящ стартъп или управлявате пълнофункционална платформа като $19/месечна бизнес ОС на Mewayz, интегрирането на анализа на мъртъв код във вашия конвейер помага за налагането на хигиена на кодовата база при всяко сливане.