Show HN: Rev-dep - 20x flugger knip.dev alternative build yn Go

De ferburgen belesting op elk groeiende softwareteam

Elk softwareprojekt dat lang genôch oerlibbet stiet úteinlik foar deselde stille krisis: de koadebase begjint rapper te groeien dan it team it kin begripe. Funksjes dy't nimmen ropt, eksporten dy't makke binne foar in funksje dy't yn 2022 ferstjoerd is en rêstich ôfkard is, komponinten dy't op skiif libje, mar nea in browser berikke. Dit is gjin sleauwens - it is natuerkunde. Teams bewege fluch, easken feroarje, en entropy is relentless. De fraach is net oft jo codebase deade koade hat. De fraach is hoefolle it jo no kostet.

Neffens ûndersyk fan it team foar engineering produktiviteit fan Google besteegje ûntwikkelders gemiddeld 42% fan har kodearringstiid troch oan it lêzen en begripen fan besteande koade ynstee fan it skriuwen fan nije funksjonaliteit. As dy besteande koade tûzenen rigels omfettet dy't gjin doel mear tsjinje, skeelt dat persintaazje noch heger. Foar in team fan tsien yngenieurs binne dat yn feite fjouwer folsleine wurknimmers dy't neat produktyf dogge - net om't se lui binne, mar om't har ark net byhâlde mei de snelheid wêrmei't software âlder wurdt.

Dit is de reden wêrom't in nije golf fan ûntwikkeldersark boud op systeemtalen lykas Go en Rust echte opwining genereart yn technykirkels. Tools lykas Rev-dep - in omkearde ôfhinklikensanalysator dy't beweart dat se 20x flugger rinne dan de populêre JavaScript-basearre knip.dev - fertsjintwurdigje mear dan allinich inkrementele ferbettering. Se signalearje in fûnemintele hertinking fan hoe't wy it ûntwikkelingsproses sels ynstrumintearje.

Wat omkearde ôfhinklikensanalyse eins docht

Foardat jo begripe wêrom't snelheid sa wichtich is, helpt it te begripen hokker ark foar ôfhinklikensanalyse eins dogge. Yn in JavaScript- of TypeScript-projekt ymportearret elk bestân fan oare bestannen. Elke funksje, klasse, of konstante dy't wurdt eksportearre út in module skept in potinsjele ôfhinklikens - eat dat oare dielen fan 'e codebase kinne fertrouwe op. "Omkearde" ôfhinklikensanalyse draait dit perspektyf om: ynstee fan te freegjen "wêr hinget dizze module fan ôf," freget it "wat hinget fan dizze module ôf?"

As it antwurd op dy twadde fraach "neat" is, hawwe jo deade koade fûn. In eksport dy't neat ymportearret is ôffal. In funksje dy't neat neamt is technyske skuld mei in moanlikse rinte. Tools foar omkearde ôfhinklikens rinne systematysk jo heule projektgrafyk, kaartje elke relaasje tusken modules, en oerflak de knopen dy't gjin ynbounde ferbiningen hawwe. It resultaat is in krekte kontrôle fan alles yn jo koadebase dat feilich fuorthelle wurde koe.

Knip.dev docht dit goed foar JavaScript- en TypeScript-projekten, en it wurdt breed respektearre yn 'e mienskip. Mar it is skreaun yn JavaSkript, wat betsjut dat it rint op Node.js, wat betsjut dat it alle Node's single-threaded prestaasjebeheiningen erft by it dwaan fan grutskalige bestânsysteemtraversal en symboalanalyse. Foar in projekt mei 500 triemmen is dit goed. Foar in projekt mei 50.000 bestannen - de soarte fan monorepo dy't wirklike SaaS-produkten oandriuwt - kin de analyze minuten duorje. En minuten, op 'e kadans dy't moderne CI/CD-pipelines operearje, is in dealbreaker.

Wêrom feroaret Go de berekkening

Go is fan 'e grûn ôf ûntworpen foar krekt it soarte wurkdruk dat ôfhinklikensanalyse freget: snelle triem-I/O, poerbêste primitieven foar tagelyk, en minimale runtime-overhead. Wêr't Node.js ien taak tagelyk ferwurket op ien tried en fertrout op callbacks en belooft te falske parallellisme, kin Go tûzenen goroutines opwekke dy't wirklik parallel útfiere oer alle beskikbere CPU-kearnen. Foar in taak dy't it lêzen fan hûnderten bestannen omfettet, it parsearjen fan har AST's en it bouwen fan in grafyk fan symboalrelaasjes, fertaalt dit arsjitektoanyske ferskil direkt yn prestaasjes fan muorreklok.

De fersnelling fan 20x beweard troch Rev-dep is gjin magy - it is wat der bart as jo de juste taal oan it juste probleem oerienkomme. De gearstalde aard fan Go betsjut ek gjin JIT-opwaarmingsstraf. Fan kâlde start oant folsleine analyze wurket in Go-binêr op hast-peakprestaasjes. De praktyske ymplikaasje is dat analyse dy't 90 sekonden naam yn in node-basearre ark kin foltôgje yn minder dan 5 sekonden yn in goed ymplementearre Go-ekwivalint. Dat is it ferskil tusken in kontrôle dy't ûntwikkelders oerslaan om't it "foar altyd duorret" en ien dy't rint op elke commit sûnder dat ien de overhead fernimt.

"It bêste ark foar ûntwikkelders is ien dy't út 'e wei komt. As jo analysesuite trije minuten tafoeget oan elke CI-pipeline, sille ûntwikkelders manieren fine om it oer te slaan. Snelheid is gjin noflike om te hawwen - it is de betingst foar oannimmen."

De saaklike saak foar Codebase-hygiëne

Deade koade is net allinich in estetykprobleem foar ûntwikkelders - it hat konkrete saaklike gefolgen dy't oer de tiid gearstalle. Besjoch wat opblaasde koadebases organisaasjes eins kostje:

• Langere boutiden dy't de ynsetpipelines fertrage en it oantal releases ferminderje dat in team feilich per wike kin ferstjoere
• Hegere kognitive lading foar yngenieurs dy't oan board binne, dy't wiken moatte besteegje oan it ûnderskieden fan aktive patroanen fan ferlitten
• Fergrutte bondelgrutte dy't tapassingsprestaasjes skealje, benammen yn webapps wêr't elke kilobyte laadtiden en konverzjesifers beynfloedet
• Utwreiding fan befeiligingsflak - deade koade dy't noch ôfhinklikens befettet is noch altyd in fektor foar kwetsberens yn dy pakketten
• Testsuite bloat wêrby't testen foar fuortsmiten funksjonaliteit trochgean te rinnen, CI-minuten konsumearje, en sa no en dan mislearje op betiizjende manieren
• Falske kompleksiteitsinjalen dy't arsjitektoanyske besluten dreger meitsje, om't it ûndúdlik is wat load-bearing en wat rudimenteel is

In 2023-stúdzje troch de groep DevOps Research and Assessment (DORA) fûn dat teams mei sterke koadekwaliteitpraktiken - ynklusyf reguliere ferwidering fan deade koade - 2.4x faker ferstjoerden en 7x legere feroaringsfoutsifers hiene as teams dy't technyske skulden accumulearje lieten. De korrelaasje is net tafallich. Skjinne koadebases binne makliker om oer te redenearjen, makliker te testen, en makliker om feilich te feroarjen.

Foar bedriuwen dy't bouwe op platfoarms lykas Mewayz - dy't 138,000 brûkers machtigje oer 207 ûnderskate bedriuwsmodules, fariearjend fan CRM en lean oant fleetbehear en link-in-bio-ark - hat codebase sûnens fermannichfâldige ynset. As jo ​​platfoarm safolle funksjonele domeinen omspant, is it yntegraasjeflak tusken modules enoarm. Net brûkte eksporten yn in kearnmodule kinne falske ferwachtings meitsje foar ôfhinklike modules, unnedige werjeften yn 'e UI-laach oansette, en de ôfhinklikensgrafyk komplisearje op manieren dy't takomstige wizigingen riskant meitsje.

Yntegraasje fan ôfhinklikensanalyse yn moderne ûntwikkelingswurkflows

De wirklike krêft fan rappe tooling lykas Rev-dep is net de ienmalige skjinmeitsjen dy't it mooglik makket - it is de mooglikheid om trochgeande analyse út te fieren as ûnderdiel fan jo normale ûntwikkelingssyklus. As in deade koade scan duorret 4 sekonden ynstee fan 4 minuten, kinne jo it tafoegje oan jo pre-commit heakjes. As it 4 sekonden duorret ynstee fan 4 minuten, kin jo CI-pipeline in pull-fersyk mislearje dy't nije net-brûkte eksporten yntroduseart ynstee fan se stil te sammeljen.

Dizze ferskowing fan "quarterly cleanup event" nei "continuous quality gate" is analoog oan wat barde doe't linters rap genôch waarden om te rinnen op elke toetsoanslag yn in IDE. Foardat ESLint yn real-time rûn, waard koadestyl ôftwongen troch periodike koadebeoardielingen. Na, it waard ambient - diel fan de feedback loop ûntwikkelers belibbe wylst it skriuwen fan koade, net na. Snelle ôfhinklikensanalyse kin deselde ambient kwaliteitsdruk meitsje om deade koade.

It ynstellen fan dizze workflow omfettet typysk trije komponinten:

1. Basisline-analyze: Run it ark tsjin jo hjoeddeistige koadebase om de skaal fan besteande deade koade te begripen. Besykje net alles yn ien kear te reparearjen - triage per module en prioritearje op risiko.
2. CI-hanthavenjen: Foegje de analyze ta oan jo pipeline mei in drompel - mislearje op alle nij yntrodusearre net brûkte eksporten, mar mislearje net op besteande oant jo se opromme hawwe.
3. Planned skjinmeitsjen sprints: Brûk de útfier fan it ark om reguliere opromingswurk te begelieden, it folgjen fan deade koade as in team sûnensmetrysk oer de tiid.

Wat de Go Tooling Renêssânse-sinjalen foar SaaS-bouwers

Rev-dep makket diel út fan in breder patroan yn ûntwikkelderstooling: hege prestaasjes alternativen foar fêststelde JavaScript-ark, boud yn Go of Rust, ferskine yn elke kategory. Biome ferfong ESLint en Prettier foar in protte teams. Turbopack en Rspack ite Webpack's lunch. Bun is útdaagjend Node.js sels. De mienskiplike tried is dat dizze ark net allinich inkrementele ferbettering oanbiede - se biede stapfunksjeferbetteringen dy't feroarje wat praktysk is.

Foar SaaS-bedriuwen dy't komplekse, multi-module produkten bouwe, hat dizze tooling renêssânse direkte gefolgen foar engineering snelheid. Mewayz's 207-module-arsjitektuer - oer alles fan HR en lean oant boekingssystemen en analytyske dashboards - fertsjintwurdiget krekt it soarte fan grutte, mei-inoar ferbûn koadebase wêr't rappe, krekte ôfhinklikensanalyse operasjoneel kritysk wurdt. As in wiziging yn in dielde nutsfoarsjenningsmodule teoretysk troch tsientallen funksjemodules kin rimpelje, is it hast direkt sichtberens yn 'e eigentlike ôfhinklikensgrafyk net allinich handich - it is it soarte ynfrastruktuer dat djoere produksjeynsidinten foarkomt.

De mooglikheid om "wat dizze funksje eins brûkt" te beantwurdzjen yn minder dan fiif sekonden ynstee fan fiif minuten feroaret hoe't yngenieurs besluten nimme. It ferleget de kosten fan ûndersyk, wat betsjut dat yngenieurs faker ûndersykje, wat betsjut dat se bettere besluten nimme. Dit is it gearstalde rendemint op ynvestearring yn fluch ark dat faak oer it each wurdt as organisaasjes tinke oan útjeften foar ûntwikkeldersproduktiviteit.

Dead Code Eliminaasje diel meitsje fan jo yngenieurkultuer

Technology allinnich bout gjin skjinne koadebases - kultuer wol. Tools lykas Rev-dep jouwe de mooglikheid, mar it omsette fan dy mooglikheid yn konsekwinte praktyk fereasket organisatoaryske ynset. De meast effektive teams behannelje deade koade metriken op deselde manier as se behannelje testdekking: as in sichtbere, folge yndikator fan codebase sûnens dy't wurdt hifke yn engineering gearkomsten en yn rekken brocht yn sprint planning.

Guon spesifike kulturele praktiken dy't goed wurkje omfetsje it oanwizen fan "dagen foar wiskjen fan koade" - periodike eveneminten wêr't it eksplisite doel is om koade te ferwiderjen ynstee fan it ta te foegjen. Netlify ferneamdste dit troch it útfieren fan leaderboards dy't net-linen wiske folgje. Stripe hat iepenbier skreaun oer har praktyk fan it behanneljen fan koadeferwidering as in earsteklasse yngenieurbydrage, gelyk yn wearde oan funksjewurk. De mindset ferskowing fereasket erkennen dat de bêste koade is koade dy't net bestiet: elke rigel dy't jo net skriuwe is in rigel dy't jo nea hoege te ûnderhâlden, test, debug, of útlizze oan in nije hiere.

Foar produktbedriuwen dy't komplekse saaklike operaasjes beheare, is de parallel bûten engineering like ynstruktive. Deselde dissipline dy't koadebases sûner makket - reguliere audits, dúdlik eigendom, eliminaasje fan dingen dy't gjinien brûkt - makket saaklike prosessen ek sûner. Platfoarms lykasMewayzbinne krekt boud om bedriuwen sa'n soarte fan operasjonele dúdlikens te jaan: in unifoarme werjefte fan hokker ark wurde brûkt, hokker workflows wearde generearje en wêr't organisatoarysk deadgewicht opbout. Oft jo net-brûkte software-eksport of net-brûkte saaklike prosessen kontrolearje, de ûnderlizzende dissipline is identyk.

De ark wurde flugger, de feedback-lussen wurde strakker, en de teams dy't hjoed ynvestearje yn hygiëne-ynfrastruktuer foar codebase bouwe in komponearjend foardiel dat jierrenlang dividenden sil betelje. Rev-dep en har kohort fan Go-oandreaune ûntwikkeldersark binne net allinich ynteressante benchmarks - se binne de ynfrastruktuerlaach dy't duorsume softwaresnelheid mooglik makket. En yn in wrâld dêr't de snelheid fan iteraasje it primêre konkurrinsjefoardiel is foar softwarebedriuwen, is dat gjin perifeare soarch. It is it hiele spul.

Faak stelde fragen

Wat makket Rev-dep flugger as knip.dev?

Rev-dep is boud yn Go, in gearstalde systeemtaal optimalisearre foar tagelyk en rûge útfieringssnelheid, wylst knip.dev rint op Node.js. Dit arsjitektoanyske ferskil lit Rev-dep ôfhinklikensgrafiken analysearje en deade koade oant 20x rapper detektearje. Foar grutte monorepos as komplekse koadebases - lykas de 207-module-arsjitektuer dy't Mewayz's bedriuwssysteem op app.mewayz.com oandriuwt - fertaalt dy prestaasjekloof yn echte tiid besparre op elke CI-run.

Hoefolle deade koade sammelet in typysk groeiend projekt?

Stúdzjes en anekdoatyske rapporten fan yngenieurteams suggerearje dat folwoeksen koadebases oeral fan 10% oant 35% net brûkte of net te berikken koade kinne drage. De probleemferbiningen as teams skaal - funksjes wurde ôfret, API's feroarje, en modules wurde ferlitten sûnder skjinmeitsjen. Platfoarms lykas Mewayz, dy't mear dan 207 bedriuwsmodules konsolidearret yn ien inkeld $ 19/mo bestjoeringssysteem, fertrouwe sterk op systematyske deade koade-deteksje om de koadebase lean en ûnderhâldber te hâlden.

Is Rev-dep geskikt foar teams dy't gjin JavaScript of TypeScript brûke?

Rev-dep is op it stuit rjochte op JavaScript- en TypeScript-ekosystemen, wêrtroch it in direkt alternatyf is foar knip.dev foar dy omjouwings. Stipe foar ekstra talen kin útwreidzje as it projekt folwoeksen is. As jo ​​team web-basearre produkten of SaaS-ark bouwt - fergelykber mei hoe't Mewayz har folsleine bedriuwssysteem leveret op app.mewayz.com - en jo stack is JS/TS-swier, Rev-dep is hjoed goed wurdich te evaluearjen as diel fan jo ûntwikkelder toolchain.

Kin ik Rev-dep yntegrearje yn myn besteande CI/CD-pipeline?

Ja. Rev-dep is ûntworpen as in CLI-ark, wêrtroch it maklik is om yn elke CI / CD-pipeline te fallen neist jo besteande linting- en teststappen. It snelheidsfoardiel is benammen weardefol yn automatisearre pipelines wêr't rappere feedback-lussen de wachttiden fan ûntwikkelders ferminderje. Oft jo in slanke opstart hawwe of in platfoarm mei folsleine funksjes beheare lykas Mewayz's $ 19 / mo bedriuw OS, it yntegrearjen fan deade koade-analyze yn jo pipeline helpt by elke fúzje codebase-hygiëne te hanthavenjen.