Vaak een ontwikkelaar zal worden geconfronteerd met een keuze tussen twee mogelijke manieren om een probleem op te lossen – een die idiomatische en leesbaar, en een andere die is minder intuïtief, maar het kan beter presteren. Bijvoorbeeld in C-gebaseerde talen zijn er twee manieren om een getal te vermenigvuldigen met 2:
int SimpleMultiplyBy2(int x)
{
return x * 2;
}
en
int FastMultiplyBy2(int x)
{
return x << 1;
}
De eerste versie is eenvoudiger op te pikken voor zowel technische als niet-technische lezers, maar de tweede kan beter presteren, omdat bit verschuiving is een eenvoudigere bediening dan vermenigvuldigen. (Voor nu, laten we aannemen dat optimizer de compiler dit niet zou detecteren en te optimaliseren, maar dat is ook een overweging).
Als ontwikkelaar, die beter als een eerste poging zou zijn?
1, Autoriteit 100%
U gemist.
Eerste code op juistheid, dan voor de duidelijkheid (de twee zijn vaak verbonden, natuurlijk!). Tot slot, en alleen als je echt empirisch bewijs dat je eigenlijk nodig is, kun je kijken naar optimalisatie. Premature optimalisatie is echt kwaad. Optimalisatie kost bijna altijd je tijd, helderheid, onderhoudbaarheid. Je zou beter zorg ervoor dat u koopt iets goeds mee.
Merk op dat een goede algoritmen bijna altijd winnen van gelokaliseerde tuning. Er is geen reden waarom je niet de code dat is correct, duidelijk en snel te hebben. U zult onredelijk geluk om er te beginnen uitstappen gericht op `fast’ wel.
2, Autoriteit 49%
IMO voor de hand liggende leesbare versie eerst, totdat prestaties worden gemeten en een snellere versie is vereist.
3, Autoriteit 37%
Neem het van Don Knuth
Premature optimalisatie is de wortel van alle kwaad (of in ieder geval het grootste deel van het) in de programmering.
4, Autoriteit 16%
Leesbaarheid 100%
Als uw compiler de “x * 2” = & gt niet kan doen; “X & lt; & lt; 1”! Optimalisatie voor u – krijg je een nieuwe compiler
Bedenk ook dat 99,9% van de tijd van uw programma wordt besteed aan het wachten op input van de gebruiker, in afwachting van database-queries en wachten op het netwerk reacties. Tenzij je doet het meerdere 20 bajillion keren, gaat het niet merkbaar te zijn.
5, Autoriteit 7%
Leesbaarheid zeker. Maak je geen zorgen over de snelheid tenzij iemand klaagt
6, Autoriteit 7%
In uw gegeven voorbeeld 99,9999% van de compilers die er zijn zal dezelfde code voor beide gevallen te genereren. Welke illustreert mijn algemene regel -. Write voor de leesbaarheid en onderhoudbaarheid eerst, en optimaliseren alleen wanneer u
7, Autoriteit 7%
De leesbaarheid.
Coding voor de prestaties heeft zijn eigen uitdagingen. Joseph M. Nieuwkomer zei dat het goed
Optimization telt alleen als het
telt. Wanneer het erop aankomt, is het van belang een
veel, maar totdat je weet dat het
zaken, niet veel tijd te verspillen
het doen. Zelfs als je weet dat het er toe doet,
je moet weten waar het er toe doet.
Zonder gegevens over de prestaties, zal u niet
weet wat te optimaliseren, en je zult
waarschijnlijk de verkeerde dingen te optimaliseren.Het resultaat zal obscure, hard te zijn
schrijven, moeilijk te debuggen, en moeilijk te
code die niet wordt opgelost onderhoud van uw
probleem. Zo heeft het dubbele
Nadeel van (a) het vergroten
software-ontwikkeling en software
onderhoudskosten, en (b) zonder
prestaties effect.
8, Autoriteit 4%
leesbaarheid. De tijd om te optimaliseren is als je naar beta-testen. Anders kun je nooit echt weet wat je nodig hebt om de tijd te besteden aan.
9, Autoriteit 4%
Ik zou gaan voor leesbaarheid eerste. Gezien het feit dat met de aard van geoptimaliseerde talen en enorm geladen machines hebben we in deze dagen, het grootste deel van de code die we schrijven in leesbare manier fatsoenlijk uit te voeren.
In sommige zeer zeldzame scenario’s, waarin je er vrij zeker van bent dat je een prestatieflessenhals zult hebben (misschien van een aantal slechte ervaringen uit het verleden), en je erin bent geslaagd een rare truc te vinden die je een enorm prestatievoordeel kan geven, kun je kan daarvoor gaan. Maar je moet dat codefragment heel goed becommentariëren, wat zal helpen om het leesbaarder te maken.
Antwoord 10, autoriteit 3%
Een factor die vaak over het hoofd wordt gezien in dit debat is de extra tijd die een programmeur nodig heeft om minder leesbare code te navigeren, te begrijpen en aan te passen. Als je bedenkt dat de tijd van een programmeur honderd dollar per uur of meer kost, zijn dit zeer reële kosten.
Elke prestatiewinst wordt gecompenseerd door deze directe extra kosten in ontwikkeling.
Antwoord 11, autoriteit 3%
Als je daar een opmerking met uitleg plaatst, wordt het leesbaar en snel.
Het hangt echt af van het type project en hoe belangrijk prestaties zijn. Als je een 3D-game aan het bouwen bent, zijn er meestal veel algemene optimalisaties die je onderweg wilt toevoegen, en er is geen reden om dat niet te doen (laat je niet te vroeg meeslepen). Maar als je iets lastigs doet, becommentarieer het dan zodat iedereen die ernaar kijkt weet hoe en waarom je zo lastig doet.
Antwoord 12, autoriteit 2%
Het antwoord hangt af van de context. Bij het programmeren van apparaatstuurprogramma’s of het ontwikkelen van games is de tweede vorm bijvoorbeeld een acceptabel idioom. In zakelijke toepassingen niet zozeer.
Je kunt het beste in de code kijken (of in vergelijkbare succesvolleapplicaties) om te zien hoe andere ontwikkelaars het doen.
Antwoord 13, autoriteit 2%
met behulp van << zou door een micro-optimalisatie.
Dus de regel van Hoare (niet Knuts):
Voortijdige optimalisatieis de wortel van alle kwaad.
van toepassing is en u moet in de eerste plaats de beter leesbare versie gebruiken.
Deze regel wordt IMHO vaak misbruikt als excuus om software te ontwerpen die nooit kan schalen of goed kan presteren.
Antwoord 14, autoriteit 2%
Beide. Uw code moet beide in evenwicht houden; leesbaarheid en prestaties. Omdat het negeren van een van beide de ROI van het project verslechtert, wat uiteindelijk het enige is dat telt voor je baas.
Slechte leesbaarheid resulteert in verminderde onderhoudbaarheid, wat resulteert in meer middelen besteed aan onderhoud, wat resulteert in een lagere ROI.
Slechte prestaties resulteren in minder investeringen en klantenbestand, wat resulteert in een lagere ROI.
Antwoord 15, autoriteit 2%
Hoe groter de codebase, hoe beter leesbaarheid cruciaal is. Een kleine functie proberen te begrijpen is niet zo erg. (Vooral omdat de methodenaam in het voorbeeld je een idee geeft.) Niet zo geweldig voor een episch stukje uber-code geschreven door het eenzame genie die net stopte met coderen omdat hij eindelijk de top van de complexiteit van zijn vermogen heeft gezien en het is wat hij gewoon voor jou geschreven en je zult het nooit begrijpen.
Antwoord 16, autoriteit 2%
Als je je zorgen maakt over de leesbaarheid van je code, aarzel dan niet om een opmerking toe te voegen om jezelf eraan te herinneren wat en waarom je dit doet.
Antwoord 17, autoriteit 2%
Als er geen leesbaarheid is, zal het erg moeilijk zijn om prestatieverbetering te krijgen wanneer je het echt nodig hebt.
Prestaties zouden alleen verbeterd moeten worden als het een probleem is in uw programma, er zijn veel plaatsen waar een bottleneck zou zijn in plaats van deze syntaxis. Stel dat u een verbetering van 1ns op een << maar negeerde die 10 minuten IO-tijd.
Ook met betrekking tot de leesbaarheid moet een professionele programmeur in staat zijn om computerwetenschappelijke termen te lezen/begrijpen. We kunnen bijvoorbeeld een methode een wachtrij noemen in plaats van dat we putThisJobInWorkQueue moeten zeggen.
18
Het hangt af van de taak die nodig is om op te lossen. Meestal is de leesbaarheid meer importrant, maar er zijn nog steeds enkele taken wanneer je in de eerste plaats aan de prestaties denkt. En u kunt niet alleen een dag of voor profilering en optimalisatie doorbrengen nadat alles perfect werkt, omdat optimalisatie zelf mogelijk kan worden herschreven van voldoende deel van een code. Maar het is tegenwoordig niet gebruikelijk.
19
U moet altijd maximaal optimaliseren, presteren telt altijd. De reden waarom we vandaag blibdware hebben, is dat de meeste programmeurs het werk van optimalisatie niet willen doen.
Dat gezegd hebbende, kunt u altijd opmerkingen plaatsen in waar slickcodering verduidelijkt.
20
Er is geen zin in het optimaliseren als u uw knelpunten niet kent. Mogelijk hebt u een functie ingrijpend efficiënt gemaakt (meestal ten koste van de leesbaarheid tot op zekere hoogte) om te vinden dat het gedeelte van de code nauwelijks werkt, of het wordt meer tijd doorgebracht met het raken van de schijf of de database dan u ooit twiddling bits zult opslaan.
U kunt dus niet micro-optimaliseren totdat u iets te meten hebt, en dan kunt u net zo goed beginnen voor leesbaarheid.
Je moet echter in het ontwerpen van de algehele architectuur, omdat beide een enorme impact kunnen hebben en moeilijk te veranderen kunnen zijn (afhankelijk van coderende stijl en methedologieën).
21
Naar schatting is ongeveer 70% van de kosten van software in onderhoud. De leesbaarheid maakt een systeem gemakkelijker te onderhouden en daarom brengt de kosten van de software over zijn leven.
Er zijn gevallen waarin de prestaties belangrijker zijn de leesbaarheid, die zeiden dat ze weinig en ver tussen zijn.
Voordat u de leesbaarheid opoffert, denkt u ‘am I (of uw bedrijf) voorbereid om te gaan met de extra kosten die ik aan het systeem toevoegt door dit te doen? “
22
Ik werk niet bij Google, dus ik zou voor de slechte optie gaan. (optimalisatie)
In hoofdstuk 6 van de “Programming Pearls” van Jon Bentley beschrijft hij hoe een systeem een 400 keer versneld had door te optimaliseren op 6 verschillende ontwerpniveaus. Ik geloof dat de moderne implementatoren door niet om de prestaties op deze 6 ontwerpniveaus te geven, gemakkelijk 2-3 ordes van grootte van vertragen in hun programma’s kunnen bereiken.
23
Zoals bijna iedereen zei in hun antwoorden, gun ik leesbaarheid . 99 van de 100 projecten die ik heb uitgevoerd, hebben geen harde reactietijdvereisten, dus het is een gemakkelijke keuze.
Voordat u zelfs begint te coderen, moet u het antwoord al kennen. Sommige projecten hebben bepaalde prestatievereisten, zoals ‘Need Task X in Y (Milli) seconden’ te kunnen uitvoeren. Als dat het geval is, heb je een doel om mee te werken en weet je wanneer je moet optimaliseren of niet. (Hopelijk) wordt dit bepaald in de vereistenfase van uw project, niet bij het schrijven van de code.
Goede leesbaarheid en de mogelijkheid om later te optimaliseren, zijn een resultaat van het juiste softwareontwerp. Als uw software van geluidsontwerp is, moet u delen van uw software kunnen isoleren en deze herschrijven indien nodig, zonder andere delen van het systeem te breken. Naast, de meest true-optimalisatiezaken die ik heb tegengekomen (het negeren van enkele echte low-level-trucs, zijn die incidentele) in het veranderen van het ene algoritme naar de andere of caching-gegevens naar geheugen in plaats van schijf / netwerk.
24
De leesbaarheid is het eerste doelwit.
In de jaren 1970 testte het leger enkele van de toenmalige “nieuwe” technieken van softwareontwikkeling (top-down ontwerp, gestructureerde programmering, chief programmeur-teams, om er een paar te noemen) om te bepalen welke van deze een statistisch significant verschil maakten.
De enige techniek die een statistisch significant verschil in ontwikkeling maakte was …
Lege lijnen toevoegen aan programmeercode.
De verbetering van de leesbaarheid in die vooraf gestructureerde, pre-objectgeoriënteerde code was de enige techniek in deze studies die de productiviteit verbeterde.
==============
Optimalisatie mag alleen worden aangepakt wanneer het volledige project eenheid is getest en klaar voor instrumentatie. U weet nooit waar u de code moet optimaliseren.
In hun oriëntatiepuntboeken toonden Kernigan en Plauger in de late 1970-softwaretools (1976) en softwaretools in Pascal (1981) manieren om gestructureerde programma’s te creëren met behulp van Top Down Design. Ze creëerden tekstverwerkingsprogramma’s: Editors, Search Tools, Pre-Processors.
Wanneer de ingevulde tekstformufunctie is geïnstrumenteerd, ontdekten ze dat de meeste verwerkingstijd werd besteed in drie routines die tekstinvoer en uitvoer hebben uitgevoerd (in het oorspronkelijke boek, de IO-functies duurden 89% van de tijd. In het Pascal-boek deden , deze functies verbruikten 55%!)
Ze waren in staat om deze drie routines te optimaliseren en produceerden de resultaten van verhoogde prestaties met een redelijke, beheersbare ontwikkelingstijd en -kosten.
25
leesbaarheid eerst. Maar zelfs meer dan leesbaarheid is eenvoud, , in het bijzonder in termen van data-structuur.
Ik herinner me aan een student die een visie-analyseprogramma doet, die niet kon begrijpen waarom het zo traag was. Hij volgde slechts een goede programmeringspraktijk – elke pixel was een object en het werkte door het verzenden van berichten naar zijn buren …
Controleer dit
26
Ik zou zeggen voor leesbaarheid.
Maar in het gegeven voorbeeld denk ik dat de tweede versie al leesbaar genoeg is, aangezien de naam van de functie precies zegt, wat er in de functie aan de hand is.
Als we gewoon altijd functies hadden die ons vertelden, wat ze doen …
27
Hoeveel kost een uur met de processor?
Hoeveel kost een uur van programmeur tijd?
28
IMHO Beide dingen hebben niets te doen. U moet eerst voor code gaan die werkt, omdat dit belangrijker is dan prestaties of hoe goed het leest. Met betrekking tot de leesbaarheid: uw code moet in elk geval altijd leesbaar zijn.
Ik zie echter niet waarom code niet leesbaar kan worden en tegelijkertijd goede prestaties aanbieden. In uw voorbeeld is de tweede versie zo leesbaar als de eerste voor mij. Wat is er minder leesbaar over? Als een programmeur niet weet dat het verplaatsen van links hetzelfde is als vermenigvuldigd door een kracht van twee en verschuivend recht is hetzelfde als verdelen door een kracht van twee … Nou, dan heb je veel meer basisproblemen dan algemene leesbaarheid.