Modulêre software
Om fleksibele, evolúsjonêre en skalberbere systemen te meitsjen, moatte wy modulariteit hawwe, dat is dat eigendom dat ús in systeem fan ûnderen nei boppe kin meitsje (fan ûnderen nei boppen).
Earst moatte jo de modules hawwe, dus jo moatte in "argyf" fan modules hawwe. Se moatte dan útwikselber wêze, d.w.s. it moat mooglik wêze om in module te ferfangen troch in oare lykweardige module, en dat wurdt dien troch it tastean fan it útwikseljen fan ynformaasje tusken modules fia definiearre ynterfaces: de ynteraksje fan de ûnderdielen moat net fariearje as de modules fariearje.
Modulêre software ûntdekt in nij paradigma fan yntegraasje tusken komponinten mei de ûntwikkeling fan mashups (hybride webapplikaasjes), dat is, it meitsjen fan wat út ferskate boarnen, bygelyks mei it brûken fan API's dy't earst makke binne foar ferskate doelen, mar dan kombineare om in nij produkt te produsearjen.
Hoe ienfâldich moatte de modules wêze yn in modulêr systeem?
De formulieren moatte sa ienfâldich mooglik makke wurde. Elk bedriuw kin de meast yngewikkelde relaasjes op in hiel oare manier beheare (bygelyks personielbehear), mar de basisfunksjes bliuwe itselde (bgl. Lytse modules tastean grutter wergebrûk, minder ûntwikkeling tiid en konstante evolúsje (bygelyks as jo skiede de brûkersynterface, jo moatte soargje dat it is gearhingjend, bygelyks, jo moatte kinne brûke copy-paste nettsjinsteande it systeem dêr't dat UI is makke).
Il problema che si pone è, chiaramente, su come realizzare l’interazione tra moduli. Un sistema di grosse dimensioni permetteva di avere tante informazioni legate tra loro all’interno del sistema stesso, inoltre permetteva di gestire in modo univoco le informazioni relative
om tagong ta tagongsrjochten, wylst mei modules i dati se binne ferspraat en de autentikaasjemeganismen kinne farieare wurde.
Dizze ûntbining jout ús tagelyk in protte frijheid: i dati wy kinne se pleatse wêr't wy wolle, se fersprieden as wy wolle.
De yntegraasje fan alle komponinten, database, modules en ynterfaces, bart net yn in fakuüm, mar bart op in platfoarm: it is it dat wy de yntegraasje kinne útfiere, dêrom is it nedich om dit platfoarm goed te definiearjen.
Wat it oanmeitsjen fan modulêre systemen mooglik makket, is foarearst in standert oer it type ynformaasje dat troch de modules útwiksele wurdt: der moat in korrespondinsje wêze yn de mooglike kommunikaasjestreamen tusken modules. Wy kinne meardere útwikselbere skriuwsystemen hawwe as wy ien dokumintstandert hawwe, mar oant no ta is krekt it tsjinoerstelde bard: in oerhearskjende skriuwsysteem mei in grut tal dokumintformaten. Dizze situaasje hat twa negative aspekten:
- as de standert assosjearre is mei in systeem, hat dat systeem de neiging om universeel te wurden,
- questo tende a favorire la chiusura del mercato, perché c’è uno standard che nessun altro può generare, quindi il più diffuso diviene automaticamente il più forte.
De aginda is in foarbyld fan in transversale oanfraach foar alle oare oanfragen, om't der in aginda wêze moat, dêrom hat it sin om dy op systeemnivo te behearjen, en net op applikaasjenivo. It systeem is it platfoarm wêrop wy de applikaasjes útfiere, wêrtroch't wy se kommunisearje. Dit kinne wy skiede de dati út applikaasjes. Dit gâns simplifies de oprjochting fan de ynformaasje systeem: wy kinne kombinearje de dati fan twa bedriuwen makliker of brûk ferskate applikaasjes om tagong ta harren dati.
It gearfoegjen fan ynformaasjesystemen is kritysk foar it proses fan saaklike fúzje. It hawwen fan ienfâldige formulieren makket it útwikseljen fan ynformaasje makliker dan it oannimmen fan komplekse formulieren.
Modulariteit is faaks al oanwêzich út in ekstern eachpunt: dat fan de brûker. Eins sjocht er it systeem ien stik foar ien, dat wol sizze, hy sjocht allinnich it stik dat er brûkt en sjocht it as in module los fan de rest. Skynbere modulariteit is de earste stap om troch te gean nei echte modulariteit.
Hjirmei kinne wy nije inter-komponint ynteraksjes en tsjinsten meitsje. De systeemynterface wurdt ôfhinklik fan 'e omjouwing fan 'e brûker: it systeem reagearret as de brûker it nedich hat, sadat de wachttiid essensjeel wurdt om de effektiviteit fan it systeem te mjitten.
It is wichtich dat de ynterface is ûntwurpen útgeande fan de brûker, fan wat er docht: de brûker wennet oan de prosedueres, sels as se binne omslachtig en sûnder logika.
Uteinlik moat it platfoarm bewust wêze fan it wêzen fan in platfoarm: it moat net allinich de útfiering fan 'e modules tastean, mar it moat ek al dy funksjes befetsje dy't transversaal wêze kinne (bgl. aginda, e-post) dy't tagonklik binne mei it systeem primitiven (krekt as by copy-paste). Foar it systeem kinne dizze wurde sjoen as
- normale applikaasjes, mar se binne essinsjeel om te kinnen meidwaan oan de komponinten.
- Platfoarm = systeem + transversale tsjinsten.
It platfoarm is net it systeem en ferfangt it net, benammen as jo ferskate systemen hawwe (Windows, Linux, Mac ...), wêryn de middleware oernimt, meardere systemen sjen litte as wiene se ien.
Dêrom moatte modulêre systemen op syn minst 4 skaaimerken hawwe:
- de foarmen moatte ienfâldich wêze;
- de modules moatte útwikselber wêze;
- jo hawwe in platfoarm nedich dat fol is mei tsjinsten nedich foar yntegraasje;
- de ynterface moat wurde ûntworpen om te foldwaan oan dyjingen dy't de applikaasje brûke.
Al dizze skaaimerken binne keppele oan evolúsje: de modules tastean foar aparte evolúsjes en tastean de evolúsje fan it systeem. It platfoarm en ynterface moatte op syn beurt yn steat wêze om te evoluearjen neffens protokollen en prosedueres.
share:
Fyn mear fan Online Web Agency
Abonnearje om de lêste artikels per e-post te ûntfangen.
