Categoriearchief: Linux

Updates, vloek, zege? zeg het maar

Vrijwel dagelijks worden we bestookt met meldingen over hacks, security breaches en ransomware aanvallen op IT van grote instellingen en bedrijven. De schade hiervan is aanzienlijk met overlast voor klanten. Op sommige zaken kan je voorbereid zijn, tegen andere aanvallen kan je lastig(er) verdedigen. Een belangrijke rol bij deze verdediging is het onderhoud van systemen. Het up to date houden dus. Operating Systems, Libraries third party software en eigen ontwikkeling kennen fouten / zwakheden. Deze fouten / zwakheden of “Gaten” wil je natuurlijk zo snel mogelijk dichten. Misbruik hiervan worden “Zero-Day Vulnerabilities” genoemd (ook wel “Zero-Day Exploits of Zero-Day Attacks”).

Common Vulnerability Enumeration

Deze zwakheden worden bijgehouden als Common Vulnerabilities and Exposures (oorspronkelijk Common Vulnerability Enumeration – CVE’s genoemd). De score, of ook wel het CVE nummer bepaalt de ernst van de zwakheid. Deze CVE’s worden door een organisatie in de US bepaald en bijgehouden. Als systeembeheerder kan je op basis van deze CVE’s updates in operating systems en software doorvoeren. Je weet hiermee hoe belangrijk het is en wat de urgentie is.

Eeuwig support?

Bij operating systems wordt vaak onderscheid gemaakt tussen major versions en minor versions. Bijvoorbeeld, mijn Mac laptop draait nu op Mac OS Golden Gate (version 27) en subversion 2, kortom 27.2 dus. Na verloop van tijd vervalt het support van de leverancier (Mac OSX release cycle). Daarna wordt verwacht dat je een major upgrade uitvoert, naar versie 28 (die is er nog niet, maar als voorbeeld). Bij RedHat Linux bijvoorbeeld is er 5 jaar full support. Daarna kan je kiezen om een nieuwe major versie te gaan gebruiken, Maar je kan ook op de aanvankelijk versie te blijven en “Extended Support” te kopen. In deze 5 jaar extended support komen er geen minor versions meer beschikbaar.

Wil je dan nog steeds niet upgraden naar de nieuwe major versie, dan kan je 4 jaar Extended Life Cycle support kopen. Ook hiervoor geldt dat er alleen security updates beschikbaar komen. Als laatste kan er nog 4 jaar Long Life aangeschaft worden. In totaal kan je hiermee 18 jaar profiteren van support. Voor bedrijven is dit van belang en daar is een eenvoudige reden voor.

De maintenance last

Eerder schreef ik over de Business Logica van een IT afdeling of IT organisatie. Mijn conclusie hierbij is dat maintenance, het onderhouden en operationeel houden van systemen en applicaties eigenlijk de hoofdtaak is van de afdeling of organisatie. Het risico hierbij is dat het onderhoud zoveel inspanning vergt dat het uitvoeren van IT projecten er onder lijd. Dat is een probleem, want (de resultaten van) projecten versnellen de organisatie juist. En dat is van levensbelang. Dit leidt to het idee dat maintenance dus zo efficient mogelijk uitgevoerd moet worden. Dit raakt natuurlijk aan deze discussie rond updates en upgrades. Veel van de onderhoudsinspanning gaat juist in de updates en upgrades zitten. Het is dan ook niet voor niets dat RedHat 18 jaar support aanbiedt. Het idee is dat je daarmee bespaard op onderhoudswerk.

Ubuntu release cycle

Bij Ubuntu Linux hanteert men een iets andere aanpak. Ieder half jaar komt er een minor versie uit, altijd in april en november. De versies van dit jaar zijn dus 26.04 (deze draai ik zelf) en binnenkort zal versie 26-10 uitkomen. Deze versies worden dus een half jaar van support voorzien. Om de twee jaar wordt versie voorzien van support voor langere tijd. Dit wordt “Long Time Support” (LTS) versie genoemd. De laatste LTS versie is 24.04. Wil je niet telkens upgraden, dan kies je voor een LTS versie. Dit voor zakelijk toepassingen dus van belang. Overigens, tijdens deze periode van support zijn er functionele- en security updates beschikbaar. Bij de Linux distributies (RedHat, Ubuntu, Debian en SuSe bijvoorbeeld) gelden deze updates niet alleen voor het operating systeem, maar even zo goed voor alle applicaties on software die middels een repository (of een soort app store) meegeleverd worden. Dit is dus veel meer (software) dan commerciële operating systems bieden. Het zal duidelijk zijn dat ook de andere distributies een release cycle en een support aanbod hebben.

Overigens, Ik upgrade (major versions) mijn Ubuntu versies al jaren zonder problemen. Ik weet dat dit bij Debian ook kan. Het is natuurlijk geen garantie dat het lukt. Veelal is dit afhankelijk van hoe complex het systeem en de daarom geïnstalleerde software is. Het lijkt daarmee wat op het idee van "Rolling Releases" waarbij er geen vaste versie plateau's zijn, maar je telkens nieuwe versies geïnstalleerd. Voorbeelden van Linux distributies die zo'n strategie volgen zijn Gentoo Linux en Arch Linux.

De ene update is de andere niet

Veel systeem beheerder maken onderscheid tussen functionele updates en security updates (beiden worden ook wel patches genoemd). Functionele updates maken nieuwe functionaliteit beschikbaar en fixen bijvoorbeeld functionele bugs. Security updates richten zich specifiek op de security fouten die een systeem kan hebben. Er kan geredeneerd worden dat je security updates zo snel mogelijk (afhankelijk van de CVE nummer – urgentie – zie verderop in het artikel) wil doorvoeren. Dus waar je prioriteiten zou willen stellen, kan je dat hiermee. Met functionele updates zou je kunnen wachten, gesteld dat je geen last hebt van de functionele fouten die het fixed.

Het installeren van updates neemt vaak nieuwe problemen met zich mee en daar zit je al helemaal niet op te wachten. Natuurlijk bevat een nieuwe versie van software altijd Zero-Day Vulnerabilities die dan later weer ontdekt worden. Dat valt te verwachten. Maar dat bestaande (eigen) software faalt vanwege updates is erg vervelend. En dat kan wel degelijk. En als bestaande software faalt dan levert dat heel veel extra werk op en daar zitten we in onderhoud (maintenance) zeker niet op te wachten.

Update strategie

Ik ben IT organisaties tegengekomen die om deze reden altijd even wachten met het doorvoeren van updates en patches. Zij willen dan altijd een minor version achter lopen op de markt. Ze noemen dit wel de N-1 strategie. Hiermee minimaliseer je het risico dat software faalt bij nieuwe versies. Maar ik denk dan tegelijkertijd, je hebt altijd Zero-Day Vulnerabilities, altijd, per definitie.

Infrastructuur inrichting telt ook

Nu zijn niet alleen updates, upgrades en patches bepalend voor security. De totale inrichting van de infrastructuur bepaald natuurlijk ook in belangrijke mate hoe veilig de applicatie uiteindelijk is. Beperkingen middels firewall, proxy’s en reverse proxy’s, maar ook in Cloud het gebruik van Security Groups (AWS) bepalen hoe veilig e.e.a. is. Veel van deze maatregelen tref je tijdens het design en implementatie. De beheer last komt vooral voort uit zich herhalende werkzaamheden, de updates en de upgrades / patches.

Automate anything

Zoals eerder gezegd, bij beheer (maintenance) draait het hoofdzakelijk om de efficiency. Het adagium “Automatiseer zoveel mogelijk” past daar goed bij. Middels Puppet, SaltStack of Ansible kan je de configuratie van een systeem beschrijven en dus snel herbouwen. Naar mijn idee speelt automation dan een cruciale rol om de beheer last laag te houden. Het is de reden om Infrastructure as Code (IaC) te adopteren.

CIA en EPSS

Een strategie kan zijn onderscheid te maken tussen verschillende stacks. Voor operating systems in een zakelijke setting is het een goed idee te kiezen voor de LTS versie. En dat ongeacht het het open sources is of commerciële software. Hiermee kan de organisatie het langste vooruit zonder te moeten upgrade en toch security updates te hebben (minimale beheer inspanning). Daarnaast is de Confidentiality, Integrity & Availability (CIA) score van belang. Ook kan gekeken worden naar de “Exploit Prediction Scoring System” (EPSS) score. Dit is een inschatting van de kans dat een exploit daadwerkelijk misbruikt kan worden.

Het idee is, hoe hoger de score, hoe eerder het aandacht verdiend. Je kan bijvoorbeeld groepen maken, critical, high, medium en low. Elke groep kent dan een andere maximale tijd waarbinnen het geregeld moet zijn. Dit valt dan te plannen. Verder zijn publiek beschikbare systemen altijd een prioriteit. En ook hier geldt, hoe meer we automatiseren hoe beter. Een hogere mate van automation betekend een hogere efficiency.

Vloek of zegen?

Uit het bovenstaande blijkt dat updates patches en upgrades en geen vloek en geen zegen zijn. Ze zijn wel noodzakelijk. Vanwege de efficiency “Eis” van het beheer (maintenance) is het wel zaak dit zo slim mogelijk te automatiseren. Een goed opgezette strategie helpt daarbij.

Actueel

Deze week werd er een groot aantal verstoringen gemeld, vooral in Amerika. Zo is  bijvoorbeeld Microsoft getroffen.In de berichtgeving werd gesteld dat het geen hack betrof, maar een storing. Eerder al werden supermarkten getroffen door koelsystemen die gingen verwarmen in plaats van koelen. Dit was wel een hack. Maar het bleef niet beperkt tot deze bedrijven, ook Apple en Google werden getroffen. Rob Braxman legt het in detail uit. Zijn conclusie is dat AI gebruikt wordt om fouten in software te vinden zoals Zero-Days. Hij beargumenteerd dat we daarom ook AI moeten gebruiken om dat tegen te gaan. Het vinden van exploits gaat nu zo snel, dat we het ons niet kunnen veroorloven AI niet te gebruiken. Interessant detail in zijn verhaal is dat de grote vendors (Apple, Google en Microsoft) vroeg inzage krijgen in de gevonden exploits, maar Linux (community) niet. Daar waar de vendors in stilte problemen kunnen fixen, kan de Linux community dat alleen in het openbaar. Waar raakt dit het onderwerp van dit artikel? Rob Braxman stelt dat de fixes zo snel gemaakt worden dat ze nieuwe bugs introduceren.
Overigens stelt hij ook dat men in de US voorloopt met deze ontwikkeling en dat Europa(?) zal volgen. Ik vraag me af of we hierop voldoende voorbereid zijn.

Portability, nieuws, of oud nieuws?

Regelmatig ben ik in gesprek met bedrijven waarbij vaak herhaaldelijk dezelfde onderwerpen aan bod komen. Voor een deel zijn dat traditionele IT onderwerpen en voor een deel zou je ze modeverschijnsel of hype kunnen noemen. Deze onderwerpen lijken onderling een verband te hebben. Om te beginnen zijn het natuurlijk allemaal architectuuronderwerpen. Maar dat is niet wat ik bedoel. Wat ik bedoel is dat het behalen van een doelstelling bij het ene onderwerp lijkt samen te hangen met die van een ander onderwerp. Simpeler gezegd, de doelstellingen van meerdere onderwerpen zijn vaak middels een enkel design te behalen. In dit artikel belicht ik deze invalshoek.

RTO en RPO

Sinds jaar en dag proberen IT architecten te achterhalen wat de beschikbaarheid van een applicatie is (of moet zijn). Dit gegeven is een belangrijk aspect bij het design. Dit wordt Recovery Time Objective genoemd (RTO). Dat is de tijd dat een applicatie maximaal niet beschikbaar mag zijn. Als de applicatie niet beschikbaar is, of slecht functioneert, kan er data verloren gaan. Graag ontwerpen we applicaties ook daarvoor. Wat is het maximale verlies van data dat we kunnen toestaan. Dit wordt Recovery Point Objective genoemd (RPO).

Ik probeer deze vragen altijd aan bod te laten komen, maar mij valt op dat klanten hier nogal eens het antwoord niet weten. De “Business” bepaalt dit vaak aan de hand van bijvoorbeeld het financiële verlies dat geleden wordt als de applicatie niet beschikbaar of bij het verlies van data. De kosten om bepaalde RTO en RPO waarden te halen moeten opwegen tegen dit veronderstelde verlies. Dit is iets waarover je in gesprek moet gaan met de “Business”.

Meestal zijn de eisen die aan RTO en RPO gesteld worden niet zo hoog. Een goede backup (en restore) zijn dan een voldoende garantie om de applicatie binnen een paar uur termijn weer operationeel te hebben. Backup & restore is dan ook de eenvoudigste van de 4 Disaster Recovery methoden die er zijn. Het meest complexe en duurste DR scenario is multi site. Hierbij draait de applicatie op twee plekken (twee datacenters, of in combinatie met een hyper scaler). Het voordeel hiervan is dat een dergelijke setup een veel betere RTO en RPO waarden mogelijk maakt.

Welke DR scenario's zijn er dan allemaal?
Als eerste en meestal simpele DR scenario is er "Backup & restore". Bij dit scenario duurt de restore het langste (enkele uren) en zijn er de hoogte (slechtste) RTO en RPO waarden.
Als tweede is er de "Pilot Light". Hierbij draait een basis setup (vooral de data) van de applicatie ook op een andere site. Bij een disaster kan deze kant verder opgestart en opgeschaald worden. Dit gaat al sneller dan de restore van de backup.
Als derde is er het DR scenario van de "Warm Standby". De applicatie "Leeft" op twee locaties. Failover kan snel, maar het nadeel is dat altijd een van de twee onnodig actief is, dubbele kosten dus.
Als laatste DR scenario is er "Multi Site". Hierbij wordt de applicatie op beide kanten actief gebruikt en is er de kortste fail over tijd. Beide kanten worden actief gebruikt.
Voor de laatste drie DR scenario's geldt dat er data replicatie gedaan moet worden.Data moet op beide locaties beschikbaar zijn in het geval van een fail over. https://docs.aws.amazon.com/whitepapers/latest/disaster-recovery-workloads-on-aws/disaster-recovery-options-in-the-cloud.html

Kostenreductie

Een ander onderwerp dat altijd ter sprake komt zijn oplopende kosten – veelal in combinatie met het inzetten van een cloud provider / hyper scaler. De kosten zijn vaak opgelopen omdat er van alles beschikbaar is en de engineers / developers die applicaties bouwen niet direct met de kosten geconfronteerd worden. Strak sturen op kosten is best ingewikkeld en verlangt dat alle betrokkenen daaraan mee werken. Afspraken over wanneer resources verwijderd kunnen worden zijn bijvoorbeeld erg effectief, wat je niet gebruikt kost ook niets. Van datgene dat je dan nog wel gebruikt is het zaak dat optimaal te gebruiken. Right Sizing is het afstemmen van de gebruikte resources en datgene dat er echt nodig is.

Applicatie modernisatie

Hoewel Right Sizing van resources slim is, zegt het niets over hoe de applicatie resources aanspreekt. Het stroomlijnen van de applicatie is nodig om ervoor te zorgen dat het efficiënt met resources omgaat. Dit valt vaak onder wat men applicatie modernisatie noemt. Hieronder worden overigens meer zaken verstaan. Het stroomlijnen van het resources gebruik is er een, maar ook het vernieuwen van de code valt hieronder, of het vernieuwen van de runtime software. Maar pak je de applicatie aan voor een van deze redenen, waarom dan niet gelijk ook voor de andere?

Wil men de afhankelijkheid van Amerikaanse (of commerciële) software verkleinen, dan is het daarnaast zaak om andere productkeuzes te maken, bijvoorbeeld kies voor open source software en kies voor een Europese cloud provider. Dit is overigens iets waar nu steeds meer bedrijven over nadenken.

Maintenance effort

Zoals ik eerder al eens heb betoogd is het onderhoud (maintenance) de belangrijkste verantwoordelijkheden van een IT afdeling of IT bedrijf. De onderhoud inspanning voor een applicatie is echter niet gedurende de levensduur van de applicatie constant. In de meeste gevallen neemt de effort voor onderhoud vrijwel altijd toe. Veranderingen in software versies maakt dat upgraden steeds lastiger wordt en na verloop van tijd zelfs onmogelijk. Dat is ook waarom “Decommissioning” zo waardevol is voor een organisatie. Het moderniseren van een applicatie kan gebruikt worden de onderhoudsdruk te verlagen. Sterker nog, dat is de belangrijkste reden waarom je dat doet.

Digital Sovereignty en portability

Als reactie op alle geopolitieke ontwikkelingen willen bedrijven de afhankelijkheden van buitenlandse technologie verkleinen. Voor veel bedrijven best wel vervelend, want ze waren net klaar met de migratie naar een Amerikaanse Cloud provider / hyper scaler. Als je voorbereid wilt zijn en wilt kunnen garanderen dat je baas blijft van data (Data Sovereignty) en je de beschikbaarheid van de applicatie zeker wil stellen (Operational Sovereignty, samen wel Digital Sovereignty genoemd), dan wil je de applicatie en data naar een ander platform kunnen verplaatsten. Dat is dan portability waarover gesproken wordt. Het raakt hiermee aan de DR scenario’s die we eerder bespraken. De portability van een applicatie vergroten raakt daarmee ook aan de applicatie modernisatie. Mijn idee hierbij is: design ineens voor alle doelstellingen.

Naast algemene portability, is er soms sprake van specifieke data portability en software portability.

Hoe dan?

Ja hoe ontwerp je dan voor portability? Door het ontwerp vraagstuk bijvoorbeeld gelaagd aan te pakken. De onderste laag is het datacenter of de hyper scaler. Deze laag is specifiek, ze kunnen van elkaar verschillen. Services zijn verschillend, netwerken anders enz. Op deze specifieke laag kan je een platform bouwen, bijvoorbeeld een Kubernetes cluster. Dat cluster is specifiek voor het datacenter of hyper scaler waarop het draait, maar is generiek voor de applicatie containers. Draaien deze op het ene cluster, dan kunnen ze dat (in principe) ook op het andere. Deze derde laag (de applicatie) kan daarmee generiek zijn. Dat is een belangrijk deel van de portability.

Als in de applicatie ook data opgeslagen wordt, dan moet ook data replicatie geregeld worden (eerder schreef ik over data replicatie). Bovendien kunnen deze onderwerpen aangepakt worden tijdens een ronde van applicatie modernisatie. Daarmee raken deze onderwerpen dus aan elkaar.

Kortom, mijn kijk op de zaak is dat we verschillende doelstellingen kunnen behalen met één design. Door te ontwerpen voor portability op bijvoorbeeld Kubernetes slaan organisaties drie vliegen in één klap: lagere kosten, betere DR en digitale soevereiniteit”. Een doordachte architectuur die meerdere doelen dient.

Adopteert Microsoft de OSS gedragscode?

Na 15 jaar tegen Linux en Open Source software te hebben gestreden, verzet Microsoft zich niet langer. In anderhalf jaar tijd is het bedrijf van fel tegenstander veranderd tot een actief aanhanger. Dit is geweldig nieuws, want van strijd werd niemand beter, van samenwerking natuurlijk wel. Maar een interessante vraag is of het zich aan de (ongeschreven) gedragscode van de Open Source software community’s kan houden. Welke regels zijn dat eigenlijk?

Gedragscode

Gedragscode

Wie deelt heeft meer

Een groot deel van de gedragscode van Open Source software community’s vindt haar oorsprong in de hacker cultuur. De relatie tussen Open Source software projecten en hackers (developers) is van oudsher erg innig. Het zijn voor een belangrijk deel deze hackers die de software schrijven en daarom hun cultuur opleggen.

De term "hacker" wordt vaak misbruikt voor computer criminelen, iemand die 
inbreekt op systemen, data / informatie steelt of virussen schrijft. Volgens 
Wikipedia is een hacker iemand met goede computer (programmeer) skills. 
Het programmeren wordt dan ook wel hacken genoemd en er is zelfs sprake 
van een hacker cultuur. Iemand die computers binnendringt wordt “Cracker” 
genoemd. Tegenwoordig wordt de term hacker voor beide gebruikt en
dat kan verwarrend zijn.

De essentie van Open Source software projecten is gezamenlijk aan de software te werken, de bijdrages te delen en daarvan te profiteren. Het delen van broncode is daarvoor noodzakelijk anders gaat dat niet. Dus wat betreft normen en waarden, gaat het om bijdragen een een gemeenschappelijk belang – het software project. Als mensen niet delen, werkt het principe niet.

Iedereen doet mee

In Open Source software projecten telt alleen je bijdrage, je code. En vooral de kwaliteit van je code is belangrijk. Als gevolg van deze gedragscode worden mensen die willen deelnemen dan ook niet buitengesloten, niet op grond van afkomst, nationaliteit of huidskleur. Het goede nieuws voor bedrijven zoals Microsoft, je mag meedoen, maar je bijdragen moeten van goede kwaliteit zijn.

Vrijheden van OSS

Commerciële software leveranciers houden de broncode juist voor zichzelf en verkopen alleen  het recht op het gebruik van de (gecompileerde) software middels licenties. Hierin verschilt  deze software fundamenteel van Open Source software projecten, want het recht op het gebruik van Open Source software hebben eindgebruikers al en de broncode krijg je erbij. Overeenkomstig is wel dat Open Source software ook onder een licentie valt. Maar hier is de licentie bedoeld om eindgebruiker rechten te geven, de software te beschermen en ervoor te zorgen dat deze “Open” blijft.

Er zijn veel soorten Open Source software licenties. Deze licenties  
beschermen de software tegen misbruik en verlenen de eindgebruiker 
verschillende vrijheden. Volgens Richard Stallman is Vrijheid 0 
het recht om de software te gebruiken voor elk gewenst doel. 
Vrijheid 1 is het recht om de software te bestuderen en aan te passen 
(hiervoor is de beschikbaarheid van de broncode dus een voorwaarde), 
vrijheid 2 betreft het recht om de software te mogen kopiëren en 
te verspreiden en, de laatste vrijheid (3) betreft de het recht 
om de veranderde software te mogen verspreiden. Er zijn veel 
licentievormen voor Open Source software die allemaal in detail 
van elkaar verschillen. Een van de meest bekende is de 
General Public License v2 (GPL v2) die bijvoorbeeld voor 
de Linux kernel gebruikt wordt.

Het respecteren van de gebruikte licentievorm is belangrijke binnen Open Source software community’s. De voorwaarden van de verschillende Open Source software licenties zullen niet altijd in het (commerciële) belang van Microsoft zijn. Het goede nieuws is dat Microsoft vrij is de Open Source licentie (variant) te kiezen die haar het beste past.

Open standaarden

Om software onderling te laten samenwerken (interoperabiliteit) is het nodig dat standaarden gebruikt worden. Standaarden kunnen betrekking hebben op bestanden (zoals document standaarden) of bijvoorbeeld netwerk protocollen. Om deze interoperabiliteit zo goed en makkelijk mogelijk te realiseren zijn Open standaarden nodig. Open standaarden zijn door iedereen te gebruiken en toe te passen. De specificaties zijn beschreven en is geen gevaar van hoge kosten of Intellectual Property (IP). Open Source software projecten baseren zich op Open standaarden vanuit praktische (kosten) overwegingen. Daarnaast is het onmogelijk gesloten standaarden in Open Source software te implementeren, immers, dan worden de standaarden ook open en dat is eigenlijk altijd tegen de licentie van de gesloten standaard. 

Microsoft kan prima open standaarden toepassen of ze zelfs introduceren. Nadeel is wel (kan zijn)  dat anderen dat ook kunnen en er keuze vrijheid voor eindgebruikers ontstaat. Zij kunnen bijvoorbeeld een andere applicatie gebruiken om dezelfde documenten te bewerken. Deze keuze vrijheid maakt het lastig voor Microsoft, want de consequentie is dat er concurrentie op prijs en kwaliteit plaats gaat vinden. Hoe concurreer je met gratis software?

De eerste packet filter (firewall) in Linux was ipfwad. Deze werd vervangen 
door IPchains die werd opgevolgd door IPtables. Inmiddels heeft nftables 
IPtables weer opgevolgd. Commerciële software bedrijven denken er niet aan 
dit zo te doen. Ze zou moeilijk aan haar klanten kunnen uitleggen 
waarom zij haar medewerkers opnieuw op moeten opleiden en wederom een 
migratie moet uitvoeren. En wel tot drie maal toe. Open Source software 
projecten hebben deze commerciële druk niet en kunnen de technisch beste 
oplossing kiezen, ook als dat commercieel niet handig is. Maar is dit niet
te prefereren?

Het beste idee wint

Als software ontwikkelaars samenwerken in een Open Source software project, dan wordt soms de ene implementatie verkozen boven de andere. Ook kan een al bestaande implementatie van een functie vervangen door een compleet nieuwe. Er zijn geen marketing of bedrijfspolitieke redenen om deze keuze te maken. Steevast wordt daarom de (technisch) beste implementatie gekozen. De firewall code in de Linux kernel is daarvan een voorbeeld en is al drie keer volledig vervangen. De beste implementatie wint het bij Open Source software projecten uiteindelijk.

De keuze voor de beste oplossing hangt samen met het efficiënt willen zijn van software ontwikkelaars. Ze willen dan ook geen dingen dubbel doen. Bestaat functionaliteit al, dan heeft het de voorkeur dit te hergebruiken, tenzij het beter kan natuurlijk.

Microsoft heeft wel bedrijfspolitiek en wel een marketing strategie die haar keuzes beïnvloedt. Deze strategie zou strijdig kunnen blijken met de gedragscode dat de beste implementatie altijd gekozen wordt.

Trots

De individuele bijdragen aan projecten kan vanuit verschillende motieven komen. De  ontwikkelaar is bijvoorbeeld trots op zijn of haar werk en wil daar graag de eer van hebben. Ontwikkelaars verbinden immers hun eigen naam aan Open Source software projecten. Er valt eer te behalen, of roem te verliezen naar gelang je goed werk levert. Het is dan “not done” om software te (her) gebruiken zonder de namen te noemen van alle personen die eraan hebben bijgedragen. Dit heeft in essentie alles te maken met werken binnen een community van software ontwikkelaars waarin je elkaar respecteert en individuele bijdrage waardeert.

Transparant

Ontwikkelaars in Open Source community’s hebben vaak een hekel aan commercie. Er mag wel geld verdient worden, maar dan wel door een echte meerwaarde te leveren. De stellingname is dat als je iets zegt je dat waar moet maken. Mooie verkoopverhalen worden niet gewaardeerd.

Elon Musk, de CEO van zowel Tesla als SpaceX, doet regelmatig product presentaties 
zoals onlangs van de Tesla Model 3. Hoewel deze bedrijven commercieel opereren 
vinden veel technisch geïnteresseerde mensen ze cool. Uit de presentaties die 
Elon geeft blijkt dat hij technisch op de hoogte is, er echte vernieuwingen 
zijn (geen “oude wijn in nieuwe zakken”) en hij bedient zich van 
“techneuten humor”. Bovendien draagt hij gewoon een jeans en geen stropdas. 
Echt interessant is dat ook veel niet-technisch aangelegde mensen zijn 
presentaties cool vinden. Het lijkt wel of nerds populair worden.

Het logische gevolg hiervan is dat als er zich problemen voordoen (bijvoorbeeld met security issues in software) dat deze niet verzwegen worden. Openheid en transparantie zijn namelijk de norm. Dergelijke issues worden zo snel mogelijk bekend gemaakt en als gevolg daarvan komen security fixes eveneens snel beschikbaar. De community’s zijn er, evenals het NIST, van overtuigd dat “Security through obscurity” niet werkt.

Commerciële software bedrijven hebben geen goede reputatie als het gaat om transparantie bij security issues. De vraag is daarbij hoe klanten dat zien. Zouden zij het juist niet waarderen als ook Microsoft hier transparant is?

Kan Microsoft de gedragscode naleven?

Zoals gezegd, de (ongeschreven) gedragscode binnen Open Source software projecten zijn een afgeleide van de hacker cultuur. Sommige daarvan zijn ook binnen commerciële software bedrijven te vinden, zoals (o.a.) het naleven van licentievoorwaarden. Maar er zijn voldoende spelregels die lastig zullen zijn voor een groot bedrijf. De transparantie die de norm is, staat haaks op het achterhouden van software exploits en security issues. Het gebruik van open standaarden laat klanten vrij andere software te gaan gebruiken. De vier vrijheden van Open Source software zijn ook niet in het belang van commerciële software bedrijven.
Als grote bedrijven zoals Microsoft serieus willen participeren in Open Source software community’s en daarbij van de voordelen te profiteren, dan helpt het als ze zich op deze punten kunnen schikken naar de norm. Vanwege de grote commerciële en financiële belangen is dit een hele uitdaging, zowel om het te doen, maar vooral om het niet te doen.