Wanneer u een nieuw project te beginnen bent, hoe bent u van plan voor het of hoe lang duurt het?
Pseudocode? Flowcharts?
Heeft u probeert te denken van alle klassen van te voren?
TBH, heb ik nooit iets van plan. Ik krijg meteen naar het en oplossingen bedenken wanneer zich problemen voordoen. Vooral omdat de weinige keren dat ik probeerde het plannen van tevoren, zou ik altijd iets groots te vergeten, en dus de logica van de planning zou de verwachting.
Veel minder dan ik zou moeten
Ik duik altijd in, vies en dan beseffen dat ik een puinhoop hebben gemaakt. Ga dan terug en plan, en doe het goed.
maar de slordige fouten fase geeft me veel ideeën die ik echter niet van zou hebben door middel van een formele ontwerpproces.
Bewerk ik voornamelijk te krijgen in dit soort smash het toetsenbord messes bij het spelen met grotere / complex. Interessant om te zien hoe ver dingen voordat je je realiseert dat je 'het is in mijn hoofd, dus het is ok' design is 100% gebrekkig.
Het hangt er van af. De meeste dingen die ik schrijf zijn vrij eenvoudig en een groter ontwerp wordt stap voor stap opgebouwd en ik merk wat er nog ontbreekt en wat er al voltooid. Er waren nog een paar harige dingen die uitgebreide schetsen nodig en dacht om goed te krijgen, al heb ik nog niet kwam veel architectonische problemen die zo nodig is (nog jong en dat soort dingen). Meestal waren die lastig rekenen dingen.
Op mijn stage vorig jaar, mijn manager was aangenaam verrast Ik gebruikte stroomschema's voor een probleem. Hij vond het een verloren kunst met studenten deze dagen. Ik was niet zo aangenaam verrast dat ze werden beschouwd als gedateerd.
Hoe dan ook, het hangt af van de tijdlijn van het project voor mij, deadlines zijn het allerbelangrijkste natuurlijk.
Waarschijnlijk niet de beste techniek ... maar ... Ik ben van plan in de code .
Ontdek ik vaak klasse / methodes / etc. dat ik moet gewoon door te doen het op deze manier. Met dat gezegd, ik neem altijd dat mijn planning code is niet van plan om de uiteindelijke oplossing.
Daarnaast zal ik naar beneden notities schrijven detaillering "belangrijkste kenmerken" en "minor / wens features".
Bij het aannemen van een probleem van elke omvang, heb ik altijd van plan op ten minste tweemaal te schrijven.
Het hangt allemaal af van hoe groot het project het. Soms kan het maanden duren om gewoon te verzamelen alle eisen en weten precies wat het moet doen.
Als het erop aankomt om het gecodeerde gedeelte, het hangt allemaal af van hoe ingewikkeld het is. Als het erg ingewikkeld, Ik wil beginnen door simpelweg te trekken uit wat ik wil doen. Dan zal ik typ mijn pseudo-code in commentaar. Dan zal ik de code rond deze opmerkingen.
Echter, als het is eenvoudig codering. Ik zal meestal gewoon schrijven wat er op mijn hoofd en test het.
We maken gebruik van een zeer agile aanpak in dat we zullen werken op de belangrijkste delen en natuurlijk dingen zijn altijd komen om pop-up in de eisen. Dus we zullen tegemoet voor mensen als ze komen. Je bent nooit volledig precies weet wat je wilt maken aan het begin van de schepping cyclus.
Dat is mijn mening.
Het merendeel van de tijd, ik op zijn minst proberen om een algeheel diagram (zelfs alleen maar in mijn hoofd) van de manier waarop de module / het systeem gaat werken. Ik vind het leuk te weten wat ik ga doen voordat ik het doe. Het maakt de programmering eenvoudiger en sneller (we zijn over het algemeen onder strakke deadlines waar ik werk). Elke keer dat ik het niet, ik in de problemen die in het algemeen me leidt tot het uittrekken van code en het zetten is ergens anders. Ik moet toegeven, mijn proces kwam door bittere ervaring en ik heb echt heel goed in het gebruik van reguliere expressies in de code, samen met de wereldwijde zoeken en vervangen.
Iemand anders bracht een goed punt, soms moet je echt een groot systeem en dat wordt moeilijk. Ik probeer en break it down in stukjes. Ik zal werken aan iets en krijgen uitgewerkt, en te werken aan iets anders voor een tijdje en zie hoe ze met elkaar omgaan. Zelfs met plannen vooruit, ik mis dingen en moet code refactoren, maar in ieder geval ik ben niet overdoen alles want ik had tenminste een soort van een werkplan.
Het hangt af van hoe complex het probleem is dat u probeert op te lossen. Als u het nemen op een groot programmering project, moet je een zekere mate van planning voordat u begint. Als je dat niet doet, dan heb je vreselijk verdwalen in de details van de dingen die niet goed communiceert met de andere delen in een mum van tijd.
In principe, probeer dan een birds-eye view van de problemen die u nodig hebt om op te lossen te krijgen. Zien of een van de problemen zijn klein genoeg dat je ze kunt oplossen en uitzoeken wat het nodig heeft om te communiceren met de rest van uw oplossing. Beschouw het als een black-box met een API voor de buitenwereld.
Nadat u al uw blokken bedacht, zien of je nodig hebt om het probleem op te splitsen in kleinere deelproblemen, of dat u een gedetailleerd genoeg uitzicht over het hele project dat u kunt beginnen met de code.
Mijn ervaring is dat de planning helpt u problemen te voorkomen in de toekomst, je aan het denken meer over hoe de code wordt verondersteld om te groeien in de toekomst als je nodig hebt om iets toe te voegen etc.
In de meeste gevallen zult u de tijd die u besteed aan de planning wanneer u het debuggen of uitbreiding van het project op te slaan. Ook het hebben van een ruwe lay-out van het project betekent dat het gemakkelijker zal zijn om te helpen de bouw van de zwarte dozen die u nodig hebt, zodat je kunt werken met meer mensen dan alleen jezelf.
Afhankelijk van de complexiteit van het project, ik meestal beginnen met pad en papier, en schrijf een spec, en sommige pseudo-code van de control flow. Dan kan ik altijd verwijzen naar dat terwijl ik codering. Het maakt het gemakkelijker en vergt minder refactoring, omdat je het probleem niet kon worden na te denken.
Persoonlijk het hangt af van de omvang en complexiteit van het project, hoeveel mensen met wie ik werk op het, en de algemene verwachtingen bij aflevering.
Het is heel belangrijk om de algemene verwachtingen van de partijen die zullen worden met behulp van de software te begrijpen. hoe dat wordt gecommuniceerd gaat in vele richtingen - Iedereen die betrokken is bij het project moet een gemeenschappelijk begrip van wat er wordt aan gewerkt hebben.
Maar al te vaak, partijen die betrokken zijn bij de ontwikkeling van software realiseren zich niet dat de communicatie tussen de partijen is vaak de meest kritische en ondergewaardeerd deel van het project - en de belangrijkste oorzaak van project ongelukken.
Na de ervaring van een groot aantal onafgewerkte projecten , ben ik geneigd om een vereenvoudigde versie van mijn business processen te implementeren in mijn persoonlijke ontwikkeling methodologie.
Ze volgen over het algemeen de volgende structuur:
Brouw ik wat koffie en ambachtelijke een paar broodjes.
Echt het hangt af van het project. Ik heb gewerkt aan een aantal projecten in de defensie-industrie, dat 2 jaar van gedetailleerde planning voordat het schrijven van een enkele regel code, en ik heb zitten en holle en een aantal kleine hulpprogramma's van een paar vragen in een e-mail van een 3D- of textuur kunstenaar in een enkele zitting met een zak van pretzels en een kop van Joe.
In staat zijn om flowcharts, UML diagrammen, use-case woordenboeken, en uitgebreide codering normen te ontwikkelen voor de hand is een leuke manier om dingen georganiseerd te houden, en is zeker de moeite waard om op grotere projecten, grotere teams, en bedrijfskritische projecten. Maar deze dingen kosten tijd, en worden vaak overkill voor kleinere projecten.
Het enige wat je echt voor moeten zorgen is dat je een goed begrip van het probleem domein. Zo niet, de besteding van de tijd aan de voorkant om het te onderzoeken totdat je doet is altijd de moeite waard.
Toen ik in de "waterval" manier van doen zou ik een paar honderd pagina's bestaande documenten waarin alle gegevens die zouden kunnen worden ontdekt tijdens het onderzoek te schrijven. om deze enorme boekdeel van de documentatie te krijgen zou ik over het algemeen
In de afgelopen jaren heb ik na samen met Agile (SCRUM) en een totaal andere benadering hebben genomen.
Ik moet zeggen dat Agile vermindert de hoeveelheid tijd die besteed het schrijven van documenten dat zodra verval als de inkt droogt. De eigenaar product krijgt om de resultaten te zien in een veel snellere manier. Dat betekent dat ze krijgen om het project te gaan in de goede richting over de tijd te houden - zelfs als die richting verandert naarmate we ontwikkelen.
Houd in gedachten dat er is een tijd en een plaats voor beide manieren te ontwikkelen. Ik zou niet willen Jet software te bouwen met behulp van Agile!
Ik ben nog steeds op de universiteit en ik heb nog geen ervaring met het maken van grootschalige software systemen, maar ...
Het eerste wat gedaan moet worden is om uit te werken wat er wilde. Tot nu toe voor mij, dit is normaal gesproken een opdracht specificatie, maar in de echte wereld het gaat om te praten met de klant. Veel.
Dan werk ik uit hoe dat te doen wat nodig is. Voor de relatief kleine programma's die ik heb gewerkt, heb ik vormen normaal gesproken in mijn ogen een ruw idee van wat mijn programma er uit gaat zien (wat de belangrijke onderdelen van het programma zijn en hoe ze met elkaar omgaan). Dit kan spikes inhouden als ik heb geen idee hoe een deel van het programma zal werken. Ik denk niet dat deze aanpak (doen het allemaal in mijn hoofd) zal zeer goed op grotere schaal, maar de vraag was om te vragen wat we eigenlijk doen ...
Zodra ik min of meer weet wat ik probeer te doen, ik ga zitten en schrijf de code. Het is hier dat ik te ontdekken eventuele problemen in wat ik dacht.
Ik denk niet dat ik ooit heb gebruikt pseudocode om een algoritme te ontwerpen. Ik denk dat pseudo-code is te laag niveau om grote brokken van het programma te ontwerpen.
Ik heb alleen gebruik gemaakt van een flowchart op een gelegenheid om te helpen met het ontwerpen van een programma - terug toen ik de montage te leren en was vrij nieuw voor de programmering (en het was nuttig). De Mythische Man-Month zegt het volgende: ". De gedetailleerde blow-by-blow stroomschema is echter een verouderde overlast, alleen geschikt voor het initiëren van beginners tot algoritmische denken ... Ik heb nog nooit een ervaren programmeur die regelmatig gedetailleerde gemaakt gezien stroomschema's alvorens te beginnen met programma's te schrijven."
IMO 5 minuten vooruit te plannen = 1 uur van de codering ....
Zo vaak we hebben om terug te gaan en nadenken over de hele situatie, omdat we niets hadden plannen.
Het belangrijkste onderdeel moet het stroomschema zijn.
De andere details soms kunnen worden opgevangen op de vlieg.
Ik teken uitgebreide stroomdiagrammen en schrijf pseudo-code voor de meer ingewikkelde functies. Ik voel me als het tekenen van de flowchart kan ik refactoren zonder dat er bugs per ongeluk. Het maken van een visueel schema op papier, zoals een flowchart helpt me ook uitzoeken of mijn logica is eigenlijk correct. Dit werkt alleen echt voor kleine - middelgrote projecten waar de meeste van de specificaties bekend zijn.
Met meer ervaring, de noodzaak om uitgebreide flowcharts trekken en schrijf hele functie pseudo code zal meer overbodig geworden maar voordat je dat punt dat ik met nadruk stellen dat u van plan bent voordat je code te bereiken.
