# Werken op nalatenschapscodebases (of een contractor's levensduurM SK2

<!--category-- Legacy Code -->
<datetime class="hidden">2024-11-06T22:30</datetime>

# Inleiding

Als freelance ontwikkelaar is één van de vaardigheden die je snel moet leren, hoe je effectief werkt op bestaande codebases.

[TOC]

# De uitdagingen

Geskiedenissystemen hebben belangrijke uitdagingen, vooral als de belangrijkste ontwikkelaars, architecten en architecten, / en (, als je het geluk hebt om ze te krijgen,), naar . te verhuizen.

## Dokumentatie

Dit wordt vaak over het hoofd gezien, vooral in kleinere bedrijven.

1. **Nieuwe Ontwikkelaargidsen** Hoe doe je het project? *lokaal* ( meer over dit in een minuut ), welke overwegingen zijn er ( als je bijvoorbeeld een ander kader nodig hebt dan het huidige, vooral waar met Node helaas
2. **Deployment Docs** Tegenwoordig wordt CI, /, CD gezien als de gouden standaard voor het installeren, maar ' wordt vaak over het hoofd gezien dat je moet weten hoe je het systeem manueel moet installeren.. Dit geldt vooral als je aan een systeem werkt dat al een tijdje aanwezig is en veel manuelle stappen heeft.
3. **Proceduren om problemen op te lossen**; wat doe je als het systeem afvalt ? Wie bel je? Wat zijn de belangrijkste dingen om te controlerenM SK3 Dit wordt vaak over het hoofd gezien, maar is CRUCIAL in een productiesysteem
4. **Architecturaal / System-Design Docs**; hoe het systeem werkt? Wat zijn de belangrijkste componenten ? Wat sind de belangrijkste afhangspuntenM SK3 Zie dit als je routekaart bij het leren van een nieuw systeemMSC4 Het geeft een hogeMSL5niveau-overzicht op hoe het system werkt, wat kritisch kan zijn.MST6besonder in grotere systemenMst7verspreide systemen~MST8 Dit zou moeten omvatten welke broncoderepositories gebruikt wordenMSt9 welke CI-systemen werden gebruiktM st11 welke databases worden gebruikt voor elk element van de toepassingMstr12 Dit kan alles omvatten, van een eenvoudig diagram tot een voldoende~Mst13~een bloeiend UML-diagram van elke component van het systeem~Mstr14 Bijvoorbeeld in een React-toepassing zou dit typisch een diagram van de componenten en hun interactie met elkaar en met alle backend-diensten bevatten. In een .NET Core-applicatie zou dit een diagram van de dienste en hoe ze met elkaar interageren bevatten.

Dokumentatie is een van de dingen die we als ontwikkelaars vaak haatten te doen. (it's NICHT codeM SK2 maar hetMSC3s cruciaal . Zoals je kunt zien, houd ik van Markdown, met Mermaid en PlantUML kun je echt leuke diagrammen en flowcharts maken die in je documentatie kunnen worden opgenomen.

Het moet CURRENT zijn.

Er zijn verschillende niveaus van documentatie, maar in het algemeen. *Telkens je code verandert die in een document staat, moet je dat document opdateer.*.

## Het systeem lokaal draaien

Dit is vaak een uitdaging; vooral als het systeem al een tijdje bestaat. Je moet weten welke versie van Node is M SK2 . Net enz.

Ik heb vaak ontwikkelaars gezien die zeiden dat dit niet relevant is in deze dagen van cloudsystemen en grote verspreide toepassingen, maar ik ben het er niet mee eens, je moet het systeem lokaal kunnen runnen om problemen snel en effectief te ontleden.

1. Profileren - dit lijkt een 'bevorderde ontwikkelaar te zijn geworden, maar het is cruciaal om je code te kunnen profileren om te zien waar de knooppunten zitten. Dit geldt vooral voor een achterhaald systeem waar je misschien niet de luxe hebt om het systeem vanaf nul opnieuw te schrijven. [Dottrace](https://www.jetbrains.com/profiler/) en [DotMemory](https://www.jetbrains.com/dotmemory/)Ze zijn hier onbelangrijk. Vooral in ASP-applicaties.NET-applikaties ; zijn de grootste problemen meestal MSC3lekkenM SK4 in het systeemMST5 geheugenlekken\MST6\ verbindingslekken enzovoort\Mst7\ Terwijl je app een beetje FINE lijkt te laten draaien, vind je het plotselingMst8s crashing |MST9 alle geheue op de server verbruikt.
2. Problemen vinden in de ontfouter - Geweldig of niet de dagen van `Response.Write` In de Classic ASP zijn ze over. Voor een zelfs bescheiden complexe toepassing ( vooral die je niet had writtenM SK2 niet geschrevenMSC3 het is belangrijk dat ' door ' te gaan via ' codes . om een verzoek vanaf het begin via de dienst te volgen om te bepalen wat er gebeurt, of er uitzonderingen zijn die niet kunnen worden opgevangen, etc.
3. Loggen - Nogmaals vaak overlookt (sorry maar geen ASP\.NET Core uitsonderingsfilter aan de top van de stapel is niet genoeg [vorige post](/blog/onlogging), logging is een cruciaal onderdeel van het werken in code LOCALLY. Vergeet niet dat je customer-loggingtypes kunt gebruiken. [Sourcegeneratoren aanteken](https://learn.microsoft.com/en-us/dotnet/core/extensions/logger-message-generator)) in ASP
   Voor Application Insights heb je misschien 'User Journeys' en andere functies nodig; maar let op. *Dit wordt snel duur.* als het gebruikt wordt. `LogInformation` voor elke vraag. Je kan een custom Telemetry Processor gebruiken om vragen die je niet wilt filteren, te filteren.
4. Te vaak zie ik ontwikkelaars 'testen in preprod' of denken dat Unit Test dan check-in ENOUGH is in termen van testen . Het is Vreemd , daarM SK5 heeft veel waarde in zowel het gebruik van een gereedschap als Resharper ≥/ NCrunch om automatisch eenheidstests te runnen ; maar onthoud Unit Tests zijn alleen maar ; ze testen een m'unit M' van code . Je moet de visibiliteit behouden over hoe het systeem in concert met andere componenten werkt [SpecFlow](https://specflow.org/) om deze tests in een menselijk formaat te schrijven.

In elk project werk ik aan de eerste stap om het systeem te krijgen ( of een groot deel ervan) lokaal te laten draaien . Door de code te zienM SK3 de code aan te doen draaien\,\ en de code uit te breken, krijg je een gevoel van hoe het systeem werkt.

## De codebase

In elk systeem is dit jouw werk. *bron van waarheid.*, wat de doc's ook zeggen , wat anderen je vertellen over hoe het zou moeten werken, dit is hoe het werkt.

### Navigeren naar een nalatenschapscodebasis

Dit is vaak een uitdaging, het' is net als je weg vinden in een nieuwe stad zonder een routekaart . Gelukkig heb je in de applicaties een ingangspunt M SK3 een paginalaaier ♫ / een front-end API-roep enzovoort ♫.) pick a point and start there ♫

Gebruik alles wat je nodig hebt om ermee te communiceren, of het nu een Http-kliënt is, of een webpagina.

### Refactoring

In het algemeen laat dit liggen totdat je het systeem begrijpt. Het' is altijd verleidelijk om M SK2 weg te gooien en opnieuw te startenMske3 maar weerstand geeft aan deze verleidingM Ske4 Vooral voor een lopend systeem Mske5 meestalMsche6 *Het Werkt* Herbouwen / zelfs het herfactoren van een systeem is een HUGE risico . Ja, het is FUN, maar voor elke regel van code die je verandert riskeer je nieuwe spannende bugs te introduceren.

Zoals alles anders (besonder bij het aannemen van contracten) moet je de werk die je doet op een systeem rechtvaardigen . Deze rechtvaardiging moet op één van de volgende vlakken worden geconcentreerd

1. **Werkverrigting** - het systeem is langzaam en moet versneld worden.  wees nogmaals voorzichtig., wat je langzaam vindt, kan zijn hoe het systeem ontworpen is om te werken.
2. **Beveiliging** - het systeem is onveilig en moet veilig gemaakt worden. Dit is een moeilijke kwestieM SK2 vooral in een ouderwetse systemen . Met bits\-root kun je zien dat het systeem oude versies van bibliotheken gebruikt die veiligheidsproblemen kennen.
3. **Onhoudbaarheid** - het systeem is moeilijk te onderhouden en moet gemakkelijker onderhouden worden. In het algemeen wordt dit een hoop werk ; rechtvaardigt de huidige levensduur van de codebase voor dit ? Als je' meer tijd besteedt aan deze veranderingen om de onderhoudsvaardigheid te verbeteren dan jij' zou je ooit voor de klant sparen, dan is het niet waard.
4. **Gebruikerervaring** - Ik geef deze kwesties meestal prioriteit. *Gebruiker* Het maakt niet uit of je code 1% beter is; het zijn zij die betalen voor de werk die je aan het eind doet . Als je hun ervaring beter kan maken dan dat, is ' het in het algemeen waardevol.

## Het bedrijfsleven van werken aan erfgoedsystemen

Dit wordt vaak over het hoofd gezien; vooral door ontwikkelaars. Je moet in staat zijn om de werk die je doet op een systeem te rechtvaardigen ' Dit is vooral waar in een contractueel milieu, waar jeM SK4 per uur betaald wordtMSC5 UiteindelijkMST6 het is niet jouw code en niet je geldMst8 De reden waarom je een wijziging maakt, is vaak belangrijker dan de wijziging zelfMSt10

Ik heb nu meer dan een decennium als werknemer gewerkt.,, het is niet makkelijk.' Als werknemer is elke uur van je tijd een ', kosten,', voor de klant, ., je moet bewegende waarde toevoegen aan het systeem dan je kost.

Als ontwikkelaars hebben we de neiging om slechte zakenmensen te zijn We zijn op elke keer gefocust op perfectie, perfectie en perfectie. In werkelijkheid hoef je geen systeem te maken.

Op een langere termijn inbegript dit het verzekeren van elk *Nu.* code is onderhoudsbaar en kostbaar-efficiënt om te runnen. In ouderwetse systemen is dit veel moeilijker . Je moet vaak door een moeras zwemmenM SK3 je bent bang dat als je het systeem leert, je niet veel waarde kunt biedenMSC4 `I'm not making any changes` Hoe denk je? `I'm just learning the system`.
Dit is een valsheid.; jij' leert het systeem beter te maken.. jij\' leest het systeem efficiënter te maken,. jij&lt;br /&gt;'\leert het system onderhoudsvriendelijker maken. . Als een klant deze stap niet kan accepteren,; dan moet je heel voorzichtig zijn over hoe je dit communiceert.

## De mensen

Nogmaals vaak over het hoofd gezien, veel van de tijd die je als contractor binnenbrengt, omdat een belangrijk persoon weg is (doe je niet meegaan in de politiek van dit project ; Het is niet jouw zorgM SK6 Je moet in staat zijn om met de mensen te kunnen werken die er zijn om de doelen van het project te bereiken.
In een contract heb je in het algemeen de voorwaarden van je contract uitgedrukt: (in mijn huidige contract is het 's 'verbesseren van betrouwbaarheid en verminderen van de lopende kosten.

Hou in gedachten wie je directe contact is; vooral in de eerste paar maanden . Informeer ze ( je zal waarschijnlijk winnenM SK3 heb geen nieuwe functies om te trotseren als je het systeem bekijktMSC4 Ik stuur meestal elke week een samenvattings-email naar mijn directe contact.

Denk eraan, dit is de persoon die je rekening zal goedkeuren ; er zouden geen verrassingen moeten zijn op de rekeningtijd. Als je de code regelmatig begint te controleren, dan is dat minder een probleemM SK3 je hebt een dossier van precies wat je deed en de impact die het hadMST4 Tot dan toeM ST5 moet je hen informeert houdenM st6
**Ze moeten weten wat je deed en waarom ze je daarvoor zouden moeten betalen.**

## betrouwbaarheid

Nogmaals, terug naar de legatiecode ; als je een verandering maakt in het algemeen moet je ze uitzetten. Zelfs de beste van ons zal dit af en toe opgooienM SK3 vooral in legaciecodesystemen zal er iets zijn. *Je kon het niet weten.* wanneer je dit uitzet. Dit gaat terug naar het inloggen - als je een stagingserver hebt die een LOT inlogt ( maar voor een korte tijd bewaard isM SK3 dan kun je bij dit uitzetten meer informatie verzamelen over wat mislukte.

Hoe goed je ook bent, , hoeveel lokaal testen je hebt gedaan,'we zijn allemaal menselijk.. Dit is een belangrijk onderdeel van de 'doen,' niet inzetten op een vrijdag,MSC5regel,M SK6 verwachten dat een inzet een nieuw probleem op het systeem zal veroorzaken.. Wees bereid om te werken tot het opgelost is,MST8MST9 Als je het niet weet,Mst10Weet niet waarom het mislukte,MSt11 voeg meer tests toe om het probleem te herhalen en meer afteken zodat je gelijkaardige problemen in de toekomst kan krijgen.MST12

Vooral voor productiesystemen kan je stagingssysteem niet 1:1 ( zijn, vooral als het om lading gaat), gereedschap zoals [k6](https://k6.io/) Het kan je helpen om lading te simuleren ( nog beter lokaal, waar je de juiste profilering kunt doen zoals eerder gezegd).

## Deployment

Nogmaals vaak overlookt in de fervour voor CI/CD is de reden van deze. EenvoudigeM SK2 Je gaat eruit halen . Een zeer snelle en efficiënte manier om een systeem te ontplooien betekent dat wanneer je het breekt, je het ook sneller kunt repareren.

Een efficiënt mechanisme om code te repareren en uit te voeren is essentieel voor een efficiënt ontwikkelingsproces.

## 'Fixing Legacy Apps'

Ik citeer dit omdat het een probleem is.

- Loopende Patches

Dit is het proces van het simpele repareren van de bestaande code; nogmaals zorgen dat je grondig toetst en procesen in werking hebben om terug te keren.
I won't liegen dit soort ontwikkeling is zelden FUN omdat je waarschijnlijk nog steeds door de woestijn van de bestaande codebase zweeft.

Zoals gewoonlijk moet je ervoor zorgen dat je SOME FORME van toets hebt om de huidige code uit te halen; idealiter zou het ook moeten testen voor falen voor het probleem dat je probeert op te lossen voordat je de oplossing maakt.
.
Ze IDYLL voor dit is om een eenheidstest te hebben dat nauwkeurig op het gebied van de code richt die je moet repareren, maar dit is vaak buiten het bereik van het werk voor grote systemen.

I'd gebruiken meestal een testsysteem in deze volgorde van voorkeur.

1. Eenheidstests - nogmaals, deze zijn voorgesteld omdat je ze kunt aanpassen om alleen de code te oefenen die je aan het werk bent . Maar in een achterhaald systeem zijn deze vaak niet aanwezig
2. Integratietests - Dit is een overbelaste term, want het kan alles omvatten van een eenheidstest dat door meerdere lagen van code gaat. [Bevestig](https://github.com/VerifyTests/Verify) Zelfs tot Selenium-testen. In het algemeen wil je het systeem als geheel testen; maar let op dat deze tests langzaam en breekbaar kunnen zijnM SK2 Verifiëren kan vaak een geweldige aanpak zijn voor ouderwetse systemen, want je kunt er tenminste MSC3verifiëringMスク4 mee doen.
3. Handtests - Ieder ontwikkelaar moet proberen handtests te doen voor elke codechecking. Dit zorgt ervoor dat wat je verwacht van de \'gebruikerM SK3 (dat dit een echte gebruiker of een andere component van het systeem kan zijn die met jouw code interageert, te zien is wat ze daadwerkelijk zien.MSC6 Het kan zo eenvoudig zijn als het systeem lokaal te runnen en de output van een pagina te controleren of zo complex als het uitvoeren van een hele reeks testen op een stagingserver.

- Zwiebel skinning
  Voor het werken aan ouderwetse systemen heb je meestal niet de luxe van een volledige herwerking.

Om PARTS van een systeem te upgraderen, kan je onderdelen identificeren die uit een bestaande monolith kunnen worden verdeeld in een microservice ( voor een bepaalde waarde van 'micro'). Dit kan een fantastische manier zijn om een systeem aan te beginnen te moderniseren zonder het risico op een volledige herwerking.
Common examples might be splitting off API endpoints into new projects which use more updated elements. The terror of DRY can come in play here however . Een slecht gestructureerde oplossing heeft vaak veel 'helperM SK3 or 'serviceMska5 componenten die echt in verschillende projecten zouden moeten zitten (or zelfs in nuget-pakketten voor meer wereldwijde hergebruikingMske7

Ik zal deze aanpak verder behandelen in een toekomstige artikel, want het is een belangrijk element van hoe ik werk met oude systemen.

# Het wordt betaald

Nu we dit allemaal hebben, komt het lastige probleem van de betaling.

**Betalingsproblemen Ik kijk ernaar uit.**

Als ze late betalen, afhankelijk van je contract maar op VAST binnen 30 dagen, maar in het algemeen dichter bij 7;, is dat een slecht teken.

Doe er niet mee om te ruzieen, als je je werk hebt gedaan en je moet op tijd betaald worden.3 Het maakt niet uit hoeveel je ervan geniet.5 Als een slechte klant je kan uitbuiten, zal hij dat doen.6 Het is nooit waard.7

Wees eerlijk; betaal alleen voor de tijd die je daadwerkelijk werkte; zorg ervoor dat het duidelijk is wat en waarom je het deed.

Ik heb teams van ontwikkelaars geleid en ik ben ' een ontwikkelaar geweest; I'm ' een contractor en I'' een klant. Ik heb alle kanten van dit gezien en ik kan je vertellen; als je niet op tijd betaald krijgt, dan moet je verdergaan. Op de andere kant- als je een contracteur hebt( of een FTE) die' niet levert, dan moeten jullie dit snel aanpakken. Iedereen heeft persoonlijke problemen maar vooral in een contractuele omgeving moet je waarde leveren of niet betalen voor de tijd wanneer je niet bent't.

Wat betreft de prijs; vind je je niveau; persoonlijk betaal ik meer voor projecten waar ik meer verantwoordelijkheid heb M SK2 of die ik niet doe ' zien er niet leuk uit ). betaal ik minder voor projecten waarin ik een nieuwe technologie leer of start-ups doe.

# In slotting:

Nou, dat is het. Ik ben vandaag en morgen niet meer aan het werk voor mijn oma's begrafenis en ik ben een beetje in paniek dat ik een HUGE nalatenschapssysteem heb om te leren.