De modulair programmeren is een techniek die wordt gebruikt voor softwareontwikkeling, waarbij het programma is onderverdeeld in vele componenten of kleine autonome blokken, modules genaamd, die beheersbaar, logisch en functioneel zijn.
De module is een blok met uitspraken dat een bepaald probleem oplost. Elke module bevat alles wat nodig is om zijn eigen functionaliteit te vervullen en kan worden bewerkt of gewijzigd zonder de rest van het project te beïnvloeden..
Deze manier van programmeren wordt bereikt door een permanente module-interface te behouden die wordt gebruikt door de andere componenten van de software om toegang te krijgen tot de functies van elke module..
Modules leggen logische grenzen tussen componenten, waardoor de onderhoudbaarheid wordt verbeterd. Ze zijn opgenomen via interfaces, die zo zijn ontworpen dat de afhankelijkheid tussen de verschillende modules wordt geminimaliseerd.
Artikel index
Een hoofdmodule en verschillende secundaire modules vormen de modulaire programmering. Oproepen naar de functies van de hulpmodules worden gedaan vanuit de hoofdmodule.
Deze plug-ins bestaan als afzonderlijke uitvoerbare bestanden, die worden geladen wanneer de hoofdmodule wordt uitgevoerd. Elke module heeft een unieke naam die is toegewezen in de PROGRAM-instructie.
De werkteams kunnen verschillende modules afzonderlijk ontwikkelen zonder dat ze alle modules van het systeem hoeven te kennen. Elk van de modulaire applicaties is gekoppeld aan een versienummer om ontwikkelaars flexibiliteit te bieden bij het onderhouden van de module..
Een computer heeft geen uitgesplitste versie van de code nodig om deze uit te voeren. Het zijn menselijke cognitieve beperkingen die je dwingen om code in kleinere stukjes te schrijven.
Een programma kan andere functies bevatten, en het kan ook verwijzen naar functies die in andere bestanden staan. Deze functies of modules zijn sets met instructies die worden gebruikt om een bewerking uit te voeren of een waarde te berekenen.
Om de eenvoud en leesbaarheid in grote en complexe programma's te behouden, wordt een korte hoofdfunctie gebruikt in combinatie met andere functies, in plaats van een lange hoofdfunctie.
Door een programma op te splitsen in groepen modules, zal elke module gemakkelijker te begrijpen zijn en dus voldoen aan de basisrichtlijnen van gestructureerd programmeren..
Een functie bestaat uit een verklaring van zijn definitie gevolgd door opdrachten en instructies. De algemene vorm van een functie is:
Functienaam (parameterdeclaratie)
zinnen;
commando's;
uitdrukking teruggeven;
- De declaratie van de parameters vertegenwoordigt de informatie die aan de functie wordt doorgegeven.
- Extra variabelen die specifiek door de functie worden gebruikt, worden in de instructies gedefinieerd.
- Alle functies moeten een retourinstructie bevatten.
Variabelen die binnen de hoofdfunctie of in door de gebruiker gedefinieerde functies worden gedeclareerd, worden lokale variabelen genoemd. Deze hebben een waarde wanneer de functie wordt uitgevoerd, maar hun waarde blijft niet behouden wanneer de functie wordt voltooid.
Variabelen die buiten het hoofdprogramma of door de gebruiker gedefinieerde functies worden gedeclareerd, worden globale variabelen genoemd. Deze variabelen kunnen uit elke functie in het programma worden gehaald.
Modulair programmeren is behoorlijk procedureel, omdat het volledig gericht is op het schrijven van code voor functies, zonder rekening te houden met de gegevens.
Stel dat een huis elektriciteit heeft, met meerdere stopcontacten aan de muren. Met dit systeem kunt u verschillende elektrische apparaten aansluiten, bijvoorbeeld magnetron, wasmachine, droger, enz..
Deze apparaten zijn ontworpen om hun specifieke taak uit te voeren wanneer ze zijn aangesloten en ingeschakeld, ongeacht waar ze zich bevinden..
De modules van een applicatie moeten dezelfde filosofie volgen. Dit betekent dat ze alleen hun specifieke taak hoeven uit te voeren, ongeacht in welk deel van de app ze zich bevinden of zelfs met welke app ze zijn verbonden..
Net zoals een elektrisch apparaat gemakkelijk uit het stopcontact kan worden gehaald, moet een module zo worden ontworpen dat deze gemakkelijk uit een toepassing kan worden verwijderd..
Net zoals het verwijderen van een elektrisch apparaat geen invloed heeft op de functionaliteit van de andere aangesloten apparaten, zou het verwijderen van modules uit een applicatie geen invloed moeten hebben op de functionaliteit van de andere modules van die applicatie..
In Java worden modules geschreven als onafhankelijke functies. U kunt bijvoorbeeld een functie of codeblok hebben om de GPA van een student te berekenen op basis van zijn cijfers in alle cursussen die hij heeft gevolgd..
De functie moet de lijst met cijfers ophalen als invoer en vervolgens het berekende cijfergemiddelde retourneren:
Deze functie heet CalculateAverageNote. Het ontvangt als invoer een lijst met notities, met behulp van een array van gegevenstype dubbel, en retourneert het berekende gemiddelde.
In de functie wordt de lokale variabele som geïnitialiseerd op nul en vervolgens, met behulp van een for-lus, worden alle kwalificaties opgeteld bij de som. Ten slotte wordt de verkregen som gedeeld door het aantal noten, waardoor de resulterende waarde wordt geretourneerd.
Als de invoermatrix de noten 3.5, 3.0 en 4.0 had, zou deze na het toevoegen de waarde 10,5 hebben en vervolgens worden gedeeld door 3, omdat er drie noten zijn. De functie retourneert de waarde 3.5.
Meerdere programmeurs kunnen aan hetzelfde project werken als het is opgedeeld in modules. Verschillende programmeurs kunnen onafhankelijk verschillende modules van het programma ontwerpen, wat nodig is voor een groot en complex programma.
Programma's kunnen sneller worden ontwikkeld, omdat kleine, zelfstandige modules gemakkelijker te begrijpen, ontwerpen en testen zijn dan grote programma's.
De programmeur kan de nodige input leveren en controleren of de module correct is door de output te onderzoeken..
Code die voor het ene programma is geschreven, is vaak nuttig voor andere. Door modulaire programmering kunnen deze secties worden opgeslagen voor toekomstig gebruik. Omdat de code verplaatsbaar is, kunnen de opgeslagen modules worden gekoppeld aan elk ander programma dat voldoet aan de input- en outputvereisten..
Bij monolithische programmering zijn dergelijke secties van code ingebed in het programma en zijn ze niet beschikbaar voor gebruik door andere programma's..
Een module is kleiner dan een volledig programma, waardoor het gemakkelijker is om te testen. Elke module kan afzonderlijk van de rest van het programma worden geschreven en getest. Nadat een module is getest, kan deze in een nieuw programma worden gebruikt zonder deze opnieuw te hoeven testen.
Wanneer een programma moet worden gewijzigd, vereenvoudigt modulaire programmering de taak. Nieuwe of foutopsporingsmodules kunnen aan een bestaand programma worden gekoppeld zonder dat de rest van het programma verandert.
Deze programmering maakt gebruik van interfaces, wat een behoorlijk effectief idee is. Om hiervan te profiteren, worden sommige frameworks geleverd met een volledige set uitwisselbare klassen. Om persistentie af te handelen, kunnen er bijvoorbeeld meerdere klassen zijn die een persistentie-interface implementeren.
Geïntegreerde ontwikkelomgevingen (IDE's) raken hier echter in de war. U zou bijvoorbeeld kunnen proberen de bron van een methode te vinden, en de IDE weet niet welke methode u wilt zien, waardoor een lange lijst met bestanden wordt weergegeven waarin een methode met die naam bestaat..
Er zijn veel modules die maar een heel kleine functie bevatten. Elke module vereist extra parseer- en verwerkingstijd, naast de koptekst in code.
Daarom zal het gebruik van veel kleine modules een overhead toevoegen aan het buildsysteem, waardoor de pakketgrootte toeneemt.
Sommige codes veranderen bijna nooit. In die gevallen heeft het misschien niet veel zin om te proberen het er schoner of met abstracte logica uit te laten zien, als het gebruik ervan al goed werkt.
Er zijn codes die er niet al te mooi uitzien en toch zijn ze de afgelopen jaren niet veel veranderd. Er is geen reden om code te ontleden die nooit is veranderd en al goed werkt..
Modulair programmeren is slechts een concept. De praktijk kan worden toegepast in elke programmeertaal, vooral die van procedurele aard, die een afzonderlijk samengesteld programma hebben.
Componentbibliotheken die zijn opgebouwd uit afzonderlijk gecompileerde modules, kunnen worden gecombineerd tot een set met behulp van een programmeertool genaamd linker.
De namen van de functies in de verschillende modules moeten uniek zijn om hun toegang te vergemakkelijken in het geval de functies die door de hoofdmodule worden gebruikt, moeten worden geëxporteerd..
Onder de programmeertalen die het modulaire programmeerconcept ondersteunen, zijn C, Ada, PL / I, Erlang, Pascal, Algol, COBOL, RPG, Haskell, Python, HyperTalk, IBM / 360 Assembler, MATLAB, Ruby, IBM RPG, SmallTalk , Morpho, Java (pakketten worden als modules beschouwd), Perl, etc..
Modulair programmeren kan worden toegepast in C-taal omdat het het mogelijk maakt om een groot probleem op te lossen door het op te splitsen in verschillende modules.
Elk van deze modules lost een bepaald probleem op, terwijl het hoofdprogramma, de verzameling van dergelijke procedures, het probleem als geheel oplost..
Elke functie gedefinieerd in C is standaard wereldwijd toegankelijk. Dit kan gedaan worden door een header-bestand op te nemen, waarin de implementatie van de functie is gedefinieerd.
Als voorbeeld willen we een stack-datatype declareren en ook dat de implementatie en de datastructuur verborgen is voor de gebruikers.
Dit kan worden gedaan door eerst een openbaar bestand met de naam stack.h te definiëren, dat de generieke gegevens met het gestapelde gegevenstype en de functies die door het gestapelde gegevenstype worden ondersteund, bevat..
stack.h:
extern stack_var1;
extern int stack_do_something (leegte);
Nu kunt u een bestand maken met de naam stack.c dat de implementatie van het stackgegevenstype bevat:
Niemand heeft nog op dit artikel gereageerd.