Skep 'n rekenaarprogram (met prente)

Inhoud

Trappe

Rekenaarprogramme word vandag oral gebruik, van ons motors tot ons slimfone, en in byna elke werk. Soos die wêreld meer en meer digitaal word, sal die behoefte aan nuwe programme bly groei. As jy die volgende groot idee het, hoekom maak dit nie self nie? Sien Stap 1 hieronder om uit te vind hoe om `n programmeertaal te begin leer, jou idee tot `n toetsbare produk te ontwikkel en dit dan te hersien totdat dit gereed is vir publikasie.

Trappe

Deel 1 van 6: Kry `n idee

1. Hou `n dinkskrum oor idees.`n Goeie program sal `n taak verrig wat die gebruiker se lewe makliker maak. Kyk na die sagteware wat tans beskikbaar is vir die taak wat jy wil uitvoer, en kyk of daar enige maniere is waarop die proses makliker of gladder gemaak kan word. `n Suksesvolle program is een wat gebruikers baie sal baat.

Ondersoek jou daaglikse take op jou rekenaar. Is daar `n manier waarop jy sommige van daardie take met `n program kan outomatiseer?
Skryf elke idee neer. Selfs al lyk dit op die oomblik dom of bisar, kan dit in iets nuttig of selfs briljant verander.

2. Verken ander programme. wat doen hulle? Hoe kan hulle beter doen? Wat mis hulle? Deur hierdie vrae te beantwoord, kan dit jou help om idees te kry vir jou eie beskouing daarvan.

3. Skryf `n ontwerpdokument. Hierdie dokument beskryf die funksies en wat jy met die projek wil bereik. Verwysing na die ontwerpdokument tydens die ontwikkelingsproses sal help om jou projek op koers en gefokus te hou. Sien Hierdie artikel vir meer inligting oor die skryf van die dokument. Die skryf van die ontwerpdokument sal jou ook help om te besluit watter programmeertaal die beste geskik is vir jou projek.

4. Begin eenvoudig. As jy nuut is met programmering, is dit `n goeie idee om klein te begin en mettertyd te groei. Jy sal baie meer leer as jy tasbare doelwitte stel wat jy met ’n basiese program kan bereik.

Deel 2 van 6: Leer `n taal

1. Kry `n goeie teksredigeerder. Byna alle programme word in teksredigeerders geskryf en dan saamgestel om op rekenaars te loop. Alhoewel jy programme soos Notepad of TextEdit kan gebruik, word dit sterk aanbeveel dat jy `n sintaksis-verligtingsredigeerder aflaai, soos Notepad++ JEdit, of Sublime Text. Dit sal jou kode ook baie makliker maak om visueel te verstaan.

Sommige tale, soos Visual Basic, bevat `n redigeerder en samesteller in een pakket.

2. Leer `n programmeertaal. Alle programme word deur kodering geskep. Om jou eie programme te skep, moet jy vertroud wees met ten minste een programmeertaal. Die tale wat jy sal moet leer, sal wissel na gelang van die tipe program wat jy wil skep. Sommige van die nuttigste en belangrikste is:

C - C is `n laevlaktaal wat baie nou saamwerk met die rekenaar se hardeware. Dit is een van die ouer programmeertale wat steeds wyd gebruik word.

C++ - Die grootste nadeel van C is dat dit nie objekgeoriënteerd is nie. Dit is waar C++ ter sprake kom. C++ is tans die gewildste programmeertaal ter wêreld. Programme soos Chrome, Firefox, Photoshop en vele ander is almal gebou met C++. Dit is ook `n baie gewilde taal vir die skep van videospeletjies.

Java - Java is `n evolusie van die C++ taal, en is baie draagbaar. Die meeste rekenaars, ongeag die bedryfstelsel, kan `n Java Virtual Machine laat loop, wat die program byna universeel maak. Dit word wyd gebruik in videospeletjies en besigheidsagteware, en word dikwels aanbeveel as `n noodsaaklike taal.

C# - C# is `n Windows-gebaseerde taal en is een van die hooftale wat gebruik word om Windows-programme te skep. Dit is nou verwant aan Java en C++, en behoort maklik te wees om te leer as jy reeds vertroud is met Java. As jy `n program vir Windows of die Windows Phone wil maak, moet jy na hierdie taal kyk.

Objective-C - Dit is nog `n neef van die C-taal wat spesifiek vir Apple-stelsels ontwerp is. As jy programme vir iPhone of iPad wil skep, is dit die taal vir jou.

3. Laai die samesteller of tolk af. Vir enige hoëvlaktaal, soos C++, Java en vele ander, benodig jy `n samesteller om jou kode om te skakel na `n formaat wat die rekenaar kan gebruik. Daar is verskeie samestellers om van te kies, afhangende van die taal wat jy gebruik.

Sommige tale is geïnterpreteerde tale, wat beteken dat hulle nie `n samesteller nodig het nie. In plaas daarvan het hulle net `n tolk nodig vir daardie spesifieke programmeertaal wat eers op die rekenaar geïnstalleer moet word, waarna die programme direk uitgevoer kan word. Enkele voorbeelde van geïnterpreteerde tale is Perl en Python.

4. Leer basiese programmeringskonsepte. Watter taal jy ook al kies, jy sal waarskynlik `n paar basiese basiese konsepte moet verstaan. As jy weet hoe om die taalsintaksis te hanteer, kan jy baie kragtiger programme skep. Algemene konsepte is:

Verklaring van veranderlikes - Veranderlikes is die manier waarop jou data tydelik in jou program gestoor word. Hierdie data kan dan gestoor, gewysig, gemanipuleer en later in die program herroep word.

Toepassing van voorwaardelike stellings (as, anders, wanneer, ens.) - Dit is een van die basiese funksies van programme, en bepaal hoe die logika werk. Voorwaardelike stellings wentel om stellings wat `waar` of `onwaar` kan wees.

Gebruik lusse (vir, gaan, doen, ens.) - Lusse laat jou toe om prosesse oor en oor te herhaal totdat `n opdrag gegee word om te stop.

Gebruik ontsnapreekse - Hierdie opdragte voer funksies uit soos nuwelynskepping, inkeping, aanhalingstekens, ens.

Kommentaar op kode - Kommentaar is noodsaaklik om te onthou wat jou kode doen, om ander programmeerders te help om jou kode te verstaan, en om dele van kode tydelik te deaktiveer.

Verstaan gereelde uitdrukkings.

5. Soek `n paar boeke oor die taal van jou keuse. Daar is boeke vir elke programmeertaal en vir elke vlak. Jy kan programmeerboeke by jou plaaslike boekwinkel of aanlyn vind. ’n Boek kan van onskatbare waarde wees, want jy kan dit byderhand hou terwyl jy werk.

Benewens boeke, is die internet `n eindelose skatkis van gidse en handleidings. Vind gidse oor die taal van jou keuse op webwerwe soos Codecademy, Code.org, Bento, Udacity, Udemy, Khan Academy en W3Schools, om net `n paar te noem.

6. Neem `n paar lesse. Enigiemand kan hulself leer om `n rekenaarprogram te skryf, met `n bietjie goeie wil, maar soms kan `n onderwyser en `n klaskameromgewing regtig help. Een-tot-een-tyd met `n kundige kan die tyd wat dit jou neem om die basiese beginsels en konsepte van programmering te verstaan, aansienlik verminder. Klasse is ook `n goeie plek om gevorderde wiskunde en logika te leer wat nodig sal wees vir meer komplekse programme.

Lesse kos geld, so maak seker dat jy by lesse inskryf wat jou sal help om te leer wat jy wil weet.

7. Vra vrae. Die internet is `n goeie manier om met ander ontwikkelaars in verbinding te tree. As jy in een van jou projekte vashaak, vra vir hulp op werwe soos StackOverflow. Maak seker dat jy jou vrae intelligent vra en kan demonstreer dat jy reeds verskeie moontlike oplossings probeer het.

Deel 3 van 6: Bou `n prototipe

1. Begin om `n basiese program met jou kernfunksies te skryf. Dit sal die prototipe wees wat die funksionaliteit wys wat jy wil bereik. `n Prototipe is `n vinnige program, en moet gewysig word totdat jy `n ontwerp vind wat werk. Byvoorbeeld, as jy `n kalenderprogram skep, sal jou prototipe `n basiese kalender wees (met korrekte datums!) en `n manier om gebeurtenisse by te voeg.

Wanneer u u prototipe skep, gebruik u `n bo-na-onder-benadering. Los soveel detail as moontlik aan die begin uit. Voeg dan stadig fyner besonderhede by. Dit sal die prototiperingsproses versnel en sal ook verhoed dat jou kode te kompleks en onhanteerbaar word. As jou kode te moeilik word om te volg, sal jy dalk van voor af moet begin.

Jou prototipe sal dikwels gedurende die ontwikkelingsiklus verander, soos jy nuwe maniere vind om probleme te benader, of later met `n idee vorendag kom wat jy wil integreer.

Wanneer jy `n speletjie maak, moet jou prototipe pret wees! As die prototipe nie pret is nie, is die kans groot dat die volle speletjie ook nie sal wees nie.

As die meganika wat jy wil hê net nie in die prototipe werk nie, dan is dit dalk tyd om terug te gaan na die tekenbord.

2. Stel `n span saam. As jy jou program op jou eie ontwikkel, kan jy `n prototipe gebruik om `n span te bou. Met `n span kan jy foute vind, kenmerke toets en die visuele aspekte van die program vinniger ontwerp.

’n Span is beslis nie nodig vir klein projekte nie, maar sal ontwikkelingstyd aansienlik verminder.

Om `n span te lei is `n komplekse en moeilike proses, en vereis goeie bestuursvaardighede tesame met `n goeie struktuur vir die span. Sien Hierdie artikel vir meer besonderhede oor die leiding van `n groep.

3. Begin weer indien nodig. Sodra jy gemaklik is met die programmeertaal, kan jy prototipes binne `n paar dae aan die gang kry. Omdat dit so vinnig gaan, moenie bang wees om `n idee te skrap en oor te begin as jy nie tevrede is met hoe dit uitdraai nie. Dit is baie makliker om groot veranderinge in hierdie stadium aan te bring as later, wanneer die kenmerke in plek is.

4. Dokumenteer alles. Gebruik die dokumentasie-sintaksis in jou programmeertaal om kommentaar te lewer op alles behalwe die mees basiese reëls kode. Dit sal jou help om te onthou wat jy gedoen het toe jy die projek vir `n rukkie moes uitstel, en sal ander ontwikkelaars help om jou kode te verstaan. Dit is veral noodsaaklik as jy in `n programmeringspan werk.

Jy kan opmerkings gebruik om dele van jou kode tydelik te deaktiveer tydens toetsing. Sluit die kode wat jy wil deaktiveer in dokumentasie-sintaksis in en dit sal nie saamgestel word nie. Jy kan dan die opmerkings uitvee om die kode weer te laat loop.

Deel 4 van 6: Die alfa-toetsfase

1. Stel `n toetsspan saam. In die alfafase kan en moet die toetsspan klein wees. ’n Klein groepie sal jou help om geteikende terugvoer te kry en jou die geleentheid gee om een-tot-een met die toetsers te kommunikeer. Elke keer as jy die prototipe opdateer, word nuwe bouwerk na die alfa-toetsers gestuur. Die toetsers probeer dan al die funksies uit en probeer ook om die program te misluk, en dokumenteer hul resultate.

As jy `n kommersiële produk ontwikkel, maak seker dat al jou toetsers `n nie-openbaarmakingsooreenkoms onderteken. Dit sal verhoed dat hulle ander van jou program vertel, en dat hulle na die pers en ander gebruikers uitgelek word.
Neem die tyd om `n stewige toetsplan op te stel. Maak seker dat jou toetsers `n manier het om maklik foute in die program aan te meld, asook maklike toegang tot nuwe weergawes van die alfa-weergawe. GitHub en ander kodebewaarplekke is `n uitstekende manier om hierdie aspek maklik te bestuur.

2. Hou aan om jou prototipe te toets. Foute is elke ontwikkelaar se vloek. Foute in die kode en onverwagte gebruik kan allerhande probleme in `n finale produk veroorsaak. Terwyl jy aanhou werk aan jou prototipe, toets dit soveel as moontlik. Doen alles wat jy kan om foute raak te sien, en probeer dan om te verhoed dat daardie foute weer gebeur.

Probeer vreemde datums invoer as jou program datums behels. Regtig ou datums of datums ver in die toekoms kan vreemde reaksies in `n program veroorsaak.

Voer die verkeerde soort veranderlikes in. Byvoorbeeld, as jy `n vorm het wat vir die gebruiker se ouderdom vra, voer `n woord in en kyk wat gebeur met die program.

As jou program `n grafiese koppelvlak het, klik op almal. Wat gebeur as jy teruggaan na `n vorige skerm, of knoppies in die verkeerde volgorde klik?

3. Adresseer foute in prioriteitsvolgorde. Wanneer u die program in die alfa-weergawe hersien, sal u baie tyd spandeer om funksies reg te maak wat nie reg werk nie. Wanneer u alfa-toetsers se foutverslae organiseer, sal dit volgens twee kriteria gesorteer moet word: erns en Prioriteit.

Die erns van `n fout is `n maatstaf van hoeveel skade die fout veroorsaak. Foute wat veroorsaak dat die program ineenstort, data beskadig of die program laat loop, word "blokkeerders" genoem. Funksies wat nie werk nie of verkeerde resultate gee, word na verwys as `kritiek`, terwyl funksies wat moeilik is om te gebruik of swak gekodeer word na verwys word as `groot`. Daar is ook `normale`, `klein` en `triviale` foute wat kleiner afdelings of minder kritieke funksies affekteer.

Die prioriteit van `n fout bepaal die volgorde waarin jy dit aanpak wanneer jy foute probeer regmaak. Om foute in sagteware reg te stel is `n tydrowende proses en verminder die tyd wat jy het om kenmerke by te voeg en te poets. As sodanig moet u foutprioriteit oorweeg om te verseker dat u sperdatums haal. Alle `blokkeer` en `kritieke` foute het die hoogste prioriteit, soms na verwys as P1. P2 foute is gewoonlik "groot" foute wat geskeduleer is om reggemaak te word, maar sal nie verhoed dat `n produk gepubliseer word nie. P3 en P4 foute is gewoonlik nie beplande verbeterings nie, en val in die `lekker om te hê`-kategorie.

4. Voeg meer kenmerke by. Tydens die alfafase sal jy meer eienskappe by jou program voeg om dit nader aan die program te bring wat in jou ontwerpdokument uiteengesit word. Die alfa-stadium is waar die prototipe ontwikkel tot die grondslag vir die volledige program. Aan die einde van die alfafase behoort alle funksies in jou program geïmplementeer te wees.

Moenie te ver van jou oorspronklike ontwerpdokument af dwaal nie. `n Algemene probleem in sagteware-ontwikkeling is `feature creep`, waar nuwe idees heeltyd bygevoeg word, wat die oorspronklike fokus verloor en ontwikkelingstyd tussen te veel verskillende kenmerke verdeel. Jy wil hê dat jou program die beste moet wees in wat dit veronderstel is om te doen, nie `n stokperdjie nie.

5. Toets elke kenmerk soos jy dit byvoeg. Nadat u kenmerke by u program gevoeg het tydens die alfafase, stuur die nuwe bou na u toetsers. Die gereeldheid van nuwe bouwerk sal geheel en al afhang van die grootte van jou span en hoeveel vordering jy maak met die kenmerke.

6. Moenie meer kenmerke byvoeg wanneer die alfafase klaar is nie. Sodra jy alle vermoëns en funksionaliteit in jou program geïmplementeer het, kan jy uit die alfafase stap. Op hierdie stadium moet geen verdere kenmerke bygevoeg word nie, en die kenmerke wat ingesluit is, moet in wese werk. Nou kan jy oorgaan na wyer toetsing en polering bekend as die beta-fase.

Deel 5 van 6: Beta-toetsing

1. Vermeerder die groep toetsers. In die beta-fase sal die program aan `n veel groter groep toetsers beskikbaar gestel word. Sommige ontwikkelaars maak die beta-fase publiek, wat `n oop beta genoem word. Dit laat enigiemand toe om aan te meld en deel te neem aan produktoetsing.

Afhangende van die behoeftes van jou produk, kan jy dalk `n oop beta doen of nie.

2. Toets konneksie. Soos programme meer en meer met mekaar verbind word, is die kans goed dat jou program afhang van verbindings met ander produkte of verbindings met bedieners. Beta-toetsing laat jou toe om te verseker dat hierdie verbindings onder `n groter las werk, om te verseker dat jou program deur die publiek bruikbaar is wanneer dit vrygestel word.

3. Poets jou sagteware. Geen kenmerke sal meer in die beta-fase bygevoeg word nie, so die fokus kan wees op die verbetering van die estetika en bruikbaarheid van die program. Op hierdie stadium word die UI-ontwerp `n prioriteit om te verseker dat die gebruikers geen probleme ondervind om die program te navigeer en die funksies daarvan te gebruik nie.

UI-ontwerp en -funksionaliteit kan baie moeilik en kompleks wees. Daar is volledige hoëronderwyskursusse vir die ontwerp van gebruikerskoppelvlakke. Maak net seker jou eie projek is maklik om te gebruik en maklik op die oog. `n Professionele UI is dalk nie moontlik sonder `n begroting en `n span nie.

As jy die begroting het, is daar baie vryskut grafiese ontwerpers wat dalk `n UI op kontrak vir jou kan ontwerp. As jy `n stewige projek het wat jy hoop die volgende groot projek sal wees, vind `n goeie UI-ontwerper en maak hom deel van jou span.

4. Hou aan soek na goggas. Tydens die beta-fase moet u steeds foutverslae van u gebruikers katalogiseer en prioritiseer. Aangesien meer toetsers toegang tot die produk sal hê, is daar altyd kanse dat nuwe foute ontdek word. Elimineer foute op grond van hul prioriteit, sonder om jou finale sperdatums uit die oog te verloor.

Deel 6 van 6: Stel die program vry

1. Plaas jou program op die mark. Om gebruikers te kry, maak seker dat hulle weet dat jou program bestaan. Soos met enige produk, moet jy `n bietjie adverteer om mense op hoogte te bring. Die grootte en diepte van jou bemarkingsveldtog sal bepaal word deur die funksie van jou program, sowel as jou beskikbare begroting. Enkele maklike maniere om jou program bekend te maak, sluit in:

Plaas oor jou program op verwante boodskapborde. Maak seker jy volg die reëls van die forum wat jy kies sodat jou plasings nie as gemorspos gesien word nie.

Stuur persvrystellings na tegnologiewebwerwe. Vind `n paar tegnologie-blogs en -werwe wat by die genre van jou program pas. Stuur vir die redakteurs `n persverklaring met besonderhede oor jou program en wat dit doen. Voeg `n paar skermkiekies by.

Maak `n paar YouTube-video`s. As jou program ontwerp is om `n spesifieke taak uit te voer, maak `n paar YouTube-video`s wat jou program in aksie wys. Struktureer hulle as `Hoe-om`-video`s.

Skep sosiale media bladsye. Jy kan gratis Facebook- en Google+-bladsye vir jou program skep, en jy kan Twitter vir beide maatskappy- en programspesifieke nuus gebruik.

2. Hou jou program op jou webwerf aan. Vir klein programme kan jy waarskynlik die lêer op jou eie webwerf huisves. Jy sal dalk `n betalingstelsel wil insluit as jy vir jou sagteware gaan hef. As jou program baie gewild raak, moet jy dalk die lêer op `n bediener huisves wat meer aflaaie kan hanteer.

3. Stel `n ondersteuningsdiens op. Sodra jou program in die natuur vrygestel is, sal jy altyd gebruikers hê met tegniese probleme of wat nie verstaan hoe die program werk nie. Jou webwerf moet deeglike dokumentasie beskikbaar hê, sowel as `n soort ondersteuningsdiens. Dit kan `n tegniese ondersteuningsforum, ondersteunings-e-posadres, regstreekse hulp of `n kombinasie hiervan wees. Wat jy kan bied, sal afhang van jou beskikbare begroting.

4. Hou jou produk op datum. Byna alle programme vandag word gelap en opgedateer lank nadat hulle die eerste keer vrygestel is. Hierdie pleisters kan kritieke of nie-kritieke foute regmaak, sekuriteitsprotokolle opdateer, stabiliteit verbeter, of selfs funksionaliteit byvoeg of die estetika verander. Om jou program op datum te hou, hou jou mededingend.