Flexible heterogeneous software systems

H.A. Jong, de

    Research output: ThesisPhd Thesis 4 Research NOT TU/e / Graduation NOT TU/e)

    Abstract

    Hoe bouw je een flexibel software systeem uit reeds bestaande en nieuw te ontwerpen componenten? Hoe wisselen deze componenten onderling relevante gegevens uit? Hoe zorg je ervoor dat deze bundeling van aan elkaar "gelijmde" componenten, ondanks grote onderlinge verschillen (heterogeniteit) in bijv. de gebruikte programmeertaal, leidt tot de gewenste applicatie? Hoe zorg je ervoor dat die applicatie dan ook nog zo flexibel is dat er later nog uitbreidingen en veranderingen aan kunnen worden aangebracht? Dit zijn enkele vragen waar dit proefschrift een antwoord op probeert te geven. Hieronder volgt een samenvatting van de hoofdstukken uit dit proefschrift. Elk van deze hoofdstukken speelt een rol in het bouwen van een flexibel software systeem dat bestaat uit heterogene componenten. Informatie uitwisseling Zodra een software systeem uit twee of meer componenten bestaat, moet ook worden nagedacht hoe deze componenten onderling informatie uitwisselen. Om niet voor elke mogelijke uitwisseling opnieuw te hoeven verzinnen hoe die tot stand moet komen, is het wenselijk hiervoor een algemene oplossing te ontwerpen. In dit proefschrift wordt het ATerm data type beschreven, waarmee op een generieke manier informatie tussen componenten kan worden uitgewisseld. Een belangrijke eigenschap van het ATerm data type is dat ze op een zeer compacte manier kunnen worden gerepresenteerd, zodat zowel bewerkingen op de data, als overdracht van data tussen componenten met minimale inspanning gerealiseerd kan worden. Automatische vertalingen Wanneer applicatie-specifieke informatie in de ene component overgestuurd moet worden naar een andere, gebruikmakend van een generiek uitwisselingsformaat zoals een ATerm, zijn enkele vertaalslagen noodzakelijk. Specifieke informatie in de ene component moet worden vertaald naar het algemeen toegankelijke formaat om het op een generieke manier te kunnen oversturen. De ontvangende component wil vervolgens weer op zijn eigen specifieke mannier met de ontvangen informatie omgaan. De programmacode die deze noodzakelijke vertaalslagen bewerkstelligt, kan door middel van codegeneratie-technieken automatisch worden gebouwd. Dit proefschrift laat zien hoe, door op een formele manier te beschrijven welke soort informatie de componenten moeten kunnen uitwisselen, een programmabibliotheek kan worden gegenereerd in verschillende programmeertalen. Deze bibliotheken worden vervolgens gebruikt in de diverse componenten om in de brontaal van die component de uit te wisselen gegevens op te bouwen, of te inspecteren. Zenuwstelsel Net zoals een zenuwprikkel in het menselijk lichaam via een stelsel van verbonden zenuwen uiteindelijk de juiste plaats bereikt, moet er ook in een software systeem dat bestaat uit verschillende componenten een soort zenuwstelsel zijn. Dit stelsel, ook wel middleware, of co¨ordinatie-architectuur genoemd, is ervoor verantwoordelijk dat de diverse componenten in een applicatie met elkaar kunnen communiceren. In dit proefschrift wordt intensief gebruik gemaakt van de ToolBus, een programmeerbaar "zenuwstelsel". Deze co¨ordinatie-architectuur zorgt er niet alleen voor dat informatie (in de vorm van een ATerm) wordt overgedragen van de ene naar de andere component, maar doordat de ToolBus programmeerbaar is, kan het gedrag van de communicatie gestuurd worden. Zo kan bepaalde communicatie voorrang krijgen boven andere, ondergeschikt geachte communicatie en bepaalde communicatiepatronen kunnen worden verboden. Verder is het in de ToolBus mogelijk om exact aan te geven of er ´e´en-op-´e´en communicatie moet plaatsvinden tussen componenten, of dat een bepaalde boodschap juist naar iedereen die erin is ge¨interesseerd, moet worden gestuurd. Naast intensief gebruik van de ToolBus in veel van de voorbeelden in dit proefschrift, is ook een discussie opgenomen over mogelijke verbeteringen en uitbreidingen aan dit programmeerbare zenuwstelsel voor software systemen. Bestaande componenten Bij het bouwen van een software systeem, zou telkens de vraag gesteld kunnen worden: "Bestaat dit niet al?". Vaak is het antwoord op deze vraag "Ja, maar . . .", gevolgd door een uitleg waarom een bepaalde, reeds bestaande, component bijna, maar net niet helemaal voldoet. Om toch een bestaande component te kunnen (her-)gebruiken in een software systeem, is het interessant om te kijken hoe, met minimale inspanning, zo’n component toch aan de co¨ordinatie-architectuur gehangen kan worden en hoe de nodige functionaliteit vervolgens aangeboden kan worden aan de rest van de applicatie. In dit proefschrift is specifiek onderzocht hoe twee bestaande en –in de informaticawereld– bekende tekstverwerkingscomponenten "Vim" en "GNU Emacs" kunnen worden ingezet als tekstverwerker voor een programmeeromgeving. Door de voor deze programmeeromgeving noodzakelijke operaties op tekst te defini¨eren, zoals "lees dit bestand in", "ga naar regel X" en "kleur kolom X tot en met Y blauw", ontstaat een interface waaraan alle tekstverwerkers vervolgens moeten voldoen. Voor elk van deze componenten wordt dan de minimale "componentlijm" geprogrammeerd, die nodig is om de component aan deze interface te laten voldoen. Het resultaat is dat een programmeeromgeving ontstaat, waarin mensen hun eigen welbekende tekstverwerker kunnen (her-)gebruiken. Het doel om niet zelf weer zo’n pakket te ontwikkelen en door hergebruik kostenbesparend een software systeem te bouwen, is dan bereikt. Uitbreidbaarheid Een boormachine kan tegenwoordig niet alleen boren, er zijn ook opzetstukken voor te krijgen om allerhande schroeven in te draaien. Evenzo is de PC niet af als hij thuis staat, we kunnen er uitbreidingskaarten (via de PCI bus) insteken, apparaten aanhangen (USB of Firewire), of de ventilatoren ervan vervangen. In software zien we ook steeds meer de wens doorschemeren, om na installatie nog van alles te kunnen veranderen aan het systeem. De plug-ins zijn dan ook al niet meer weg te denken uit internet browsers en muziek- of videoafspeelprogrammatuur. Waar bij de boormachine en PC de uitbreidingsmogelijkheden beperkt zijn, door bijv. voorgeschreven maten, of electronische specificaties, is men in de software nog meer zoekende naar de grenzen van uitbreidingen en veranderingen. Dit proefschrift bestudeert een aantal van deze uitbreidingsarchitecturen en beschrijft hoe zo’n architectuur met behulp van de ToolBus op een structurele wijze kan worden opgezet. Waar het in bestaande systemen soms onduidelijk is wat er moet gebeuren wanneer twee plug-ins op hetzelfde punt in het systeem willen ingrijpen, kan in een programmeerbare co¨ordinatie-architectuur precies worden gespecificeerd wat het gewenste gedrag is. Drempelverlagend Wil hergebruik van componenten bijdragen aan een goedkopere manier van software ontwikkeling, dan zal er alles aan moeten worden gedaan om de integratie en interactie van componenten zo eenvoudig en flexibel mogelijk te laten zijn. Door drempels, die hergebruik van componenten in de weg staan, te verlagen, draagt dit proefschrift bij aan het succesvol bouwen van flexibele software systemen, opgebouwd uit heterogene componenten.
    Original languageEnglish
    QualificationDoctor of Philosophy
    Awarding Institution
    • University of Amsterdam
    Supervisors/Advisors
    • Klint, Paul, Promotor, External person
    • van den Brand, Mark G.J., Copromotor
    Award date1 Feb 2007
    Place of PublicationAmsterdam
    Publisher
    Publication statusPublished - 2007

    Fingerprint

    Software
    World Wide Web
    Huns

    Cite this

    Jong, de, H. A. (2007). Flexible heterogeneous software systems. Amsterdam: Universiteit van Amsterdam.
    Jong, de, H.A.. / Flexible heterogeneous software systems. Amsterdam : Universiteit van Amsterdam, 2007. 176 p.
    @phdthesis{0a5aa1176f2c45f6a4fc41f932e96e0d,
    title = "Flexible heterogeneous software systems",
    abstract = "Hoe bouw je een flexibel software systeem uit reeds bestaande en nieuw te ontwerpen componenten? Hoe wisselen deze componenten onderling relevante gegevens uit? Hoe zorg je ervoor dat deze bundeling van aan elkaar {"}gelijmde{"} componenten, ondanks grote onderlinge verschillen (heterogeniteit) in bijv. de gebruikte programmeertaal, leidt tot de gewenste applicatie? Hoe zorg je ervoor dat die applicatie dan ook nog zo flexibel is dat er later nog uitbreidingen en veranderingen aan kunnen worden aangebracht? Dit zijn enkele vragen waar dit proefschrift een antwoord op probeert te geven. Hieronder volgt een samenvatting van de hoofdstukken uit dit proefschrift. Elk van deze hoofdstukken speelt een rol in het bouwen van een flexibel software systeem dat bestaat uit heterogene componenten. Informatie uitwisseling Zodra een software systeem uit twee of meer componenten bestaat, moet ook worden nagedacht hoe deze componenten onderling informatie uitwisselen. Om niet voor elke mogelijke uitwisseling opnieuw te hoeven verzinnen hoe die tot stand moet komen, is het wenselijk hiervoor een algemene oplossing te ontwerpen. In dit proefschrift wordt het ATerm data type beschreven, waarmee op een generieke manier informatie tussen componenten kan worden uitgewisseld. Een belangrijke eigenschap van het ATerm data type is dat ze op een zeer compacte manier kunnen worden gerepresenteerd, zodat zowel bewerkingen op de data, als overdracht van data tussen componenten met minimale inspanning gerealiseerd kan worden. Automatische vertalingen Wanneer applicatie-specifieke informatie in de ene component overgestuurd moet worden naar een andere, gebruikmakend van een generiek uitwisselingsformaat zoals een ATerm, zijn enkele vertaalslagen noodzakelijk. Specifieke informatie in de ene component moet worden vertaald naar het algemeen toegankelijke formaat om het op een generieke manier te kunnen oversturen. De ontvangende component wil vervolgens weer op zijn eigen specifieke mannier met de ontvangen informatie omgaan. De programmacode die deze noodzakelijke vertaalslagen bewerkstelligt, kan door middel van codegeneratie-technieken automatisch worden gebouwd. Dit proefschrift laat zien hoe, door op een formele manier te beschrijven welke soort informatie de componenten moeten kunnen uitwisselen, een programmabibliotheek kan worden gegenereerd in verschillende programmeertalen. Deze bibliotheken worden vervolgens gebruikt in de diverse componenten om in de brontaal van die component de uit te wisselen gegevens op te bouwen, of te inspecteren. Zenuwstelsel Net zoals een zenuwprikkel in het menselijk lichaam via een stelsel van verbonden zenuwen uiteindelijk de juiste plaats bereikt, moet er ook in een software systeem dat bestaat uit verschillende componenten een soort zenuwstelsel zijn. Dit stelsel, ook wel middleware, of co¨ordinatie-architectuur genoemd, is ervoor verantwoordelijk dat de diverse componenten in een applicatie met elkaar kunnen communiceren. In dit proefschrift wordt intensief gebruik gemaakt van de ToolBus, een programmeerbaar {"}zenuwstelsel{"}. Deze co¨ordinatie-architectuur zorgt er niet alleen voor dat informatie (in de vorm van een ATerm) wordt overgedragen van de ene naar de andere component, maar doordat de ToolBus programmeerbaar is, kan het gedrag van de communicatie gestuurd worden. Zo kan bepaalde communicatie voorrang krijgen boven andere, ondergeschikt geachte communicatie en bepaalde communicatiepatronen kunnen worden verboden. Verder is het in de ToolBus mogelijk om exact aan te geven of er ´e´en-op-´e´en communicatie moet plaatsvinden tussen componenten, of dat een bepaalde boodschap juist naar iedereen die erin is ge¨interesseerd, moet worden gestuurd. Naast intensief gebruik van de ToolBus in veel van de voorbeelden in dit proefschrift, is ook een discussie opgenomen over mogelijke verbeteringen en uitbreidingen aan dit programmeerbare zenuwstelsel voor software systemen. Bestaande componenten Bij het bouwen van een software systeem, zou telkens de vraag gesteld kunnen worden: {"}Bestaat dit niet al?{"}. Vaak is het antwoord op deze vraag {"}Ja, maar . . .{"}, gevolgd door een uitleg waarom een bepaalde, reeds bestaande, component bijna, maar net niet helemaal voldoet. Om toch een bestaande component te kunnen (her-)gebruiken in een software systeem, is het interessant om te kijken hoe, met minimale inspanning, zo’n component toch aan de co¨ordinatie-architectuur gehangen kan worden en hoe de nodige functionaliteit vervolgens aangeboden kan worden aan de rest van de applicatie. In dit proefschrift is specifiek onderzocht hoe twee bestaande en –in de informaticawereld– bekende tekstverwerkingscomponenten {"}Vim{"} en {"}GNU Emacs{"} kunnen worden ingezet als tekstverwerker voor een programmeeromgeving. Door de voor deze programmeeromgeving noodzakelijke operaties op tekst te defini¨eren, zoals {"}lees dit bestand in{"}, {"}ga naar regel X{"} en {"}kleur kolom X tot en met Y blauw{"}, ontstaat een interface waaraan alle tekstverwerkers vervolgens moeten voldoen. Voor elk van deze componenten wordt dan de minimale {"}componentlijm{"} geprogrammeerd, die nodig is om de component aan deze interface te laten voldoen. Het resultaat is dat een programmeeromgeving ontstaat, waarin mensen hun eigen welbekende tekstverwerker kunnen (her-)gebruiken. Het doel om niet zelf weer zo’n pakket te ontwikkelen en door hergebruik kostenbesparend een software systeem te bouwen, is dan bereikt. Uitbreidbaarheid Een boormachine kan tegenwoordig niet alleen boren, er zijn ook opzetstukken voor te krijgen om allerhande schroeven in te draaien. Evenzo is de PC niet af als hij thuis staat, we kunnen er uitbreidingskaarten (via de PCI bus) insteken, apparaten aanhangen (USB of Firewire), of de ventilatoren ervan vervangen. In software zien we ook steeds meer de wens doorschemeren, om na installatie nog van alles te kunnen veranderen aan het systeem. De plug-ins zijn dan ook al niet meer weg te denken uit internet browsers en muziek- of videoafspeelprogrammatuur. Waar bij de boormachine en PC de uitbreidingsmogelijkheden beperkt zijn, door bijv. voorgeschreven maten, of electronische specificaties, is men in de software nog meer zoekende naar de grenzen van uitbreidingen en veranderingen. Dit proefschrift bestudeert een aantal van deze uitbreidingsarchitecturen en beschrijft hoe zo’n architectuur met behulp van de ToolBus op een structurele wijze kan worden opgezet. Waar het in bestaande systemen soms onduidelijk is wat er moet gebeuren wanneer twee plug-ins op hetzelfde punt in het systeem willen ingrijpen, kan in een programmeerbare co¨ordinatie-architectuur precies worden gespecificeerd wat het gewenste gedrag is. Drempelverlagend Wil hergebruik van componenten bijdragen aan een goedkopere manier van software ontwikkeling, dan zal er alles aan moeten worden gedaan om de integratie en interactie van componenten zo eenvoudig en flexibel mogelijk te laten zijn. Door drempels, die hergebruik van componenten in de weg staan, te verlagen, draagt dit proefschrift bij aan het succesvol bouwen van flexibele software systemen, opgebouwd uit heterogene componenten.",
    author = "{Jong, de}, H.A.",
    year = "2007",
    language = "English",
    publisher = "Universiteit van Amsterdam",
    school = "University of Amsterdam",

    }

    Jong, de, HA 2007, 'Flexible heterogeneous software systems', Doctor of Philosophy, University of Amsterdam, Amsterdam.

    Flexible heterogeneous software systems. / Jong, de, H.A.

    Amsterdam : Universiteit van Amsterdam, 2007. 176 p.

    Research output: ThesisPhd Thesis 4 Research NOT TU/e / Graduation NOT TU/e)

    TY - THES

    T1 - Flexible heterogeneous software systems

    AU - Jong, de, H.A.

    PY - 2007

    Y1 - 2007

    N2 - Hoe bouw je een flexibel software systeem uit reeds bestaande en nieuw te ontwerpen componenten? Hoe wisselen deze componenten onderling relevante gegevens uit? Hoe zorg je ervoor dat deze bundeling van aan elkaar "gelijmde" componenten, ondanks grote onderlinge verschillen (heterogeniteit) in bijv. de gebruikte programmeertaal, leidt tot de gewenste applicatie? Hoe zorg je ervoor dat die applicatie dan ook nog zo flexibel is dat er later nog uitbreidingen en veranderingen aan kunnen worden aangebracht? Dit zijn enkele vragen waar dit proefschrift een antwoord op probeert te geven. Hieronder volgt een samenvatting van de hoofdstukken uit dit proefschrift. Elk van deze hoofdstukken speelt een rol in het bouwen van een flexibel software systeem dat bestaat uit heterogene componenten. Informatie uitwisseling Zodra een software systeem uit twee of meer componenten bestaat, moet ook worden nagedacht hoe deze componenten onderling informatie uitwisselen. Om niet voor elke mogelijke uitwisseling opnieuw te hoeven verzinnen hoe die tot stand moet komen, is het wenselijk hiervoor een algemene oplossing te ontwerpen. In dit proefschrift wordt het ATerm data type beschreven, waarmee op een generieke manier informatie tussen componenten kan worden uitgewisseld. Een belangrijke eigenschap van het ATerm data type is dat ze op een zeer compacte manier kunnen worden gerepresenteerd, zodat zowel bewerkingen op de data, als overdracht van data tussen componenten met minimale inspanning gerealiseerd kan worden. Automatische vertalingen Wanneer applicatie-specifieke informatie in de ene component overgestuurd moet worden naar een andere, gebruikmakend van een generiek uitwisselingsformaat zoals een ATerm, zijn enkele vertaalslagen noodzakelijk. Specifieke informatie in de ene component moet worden vertaald naar het algemeen toegankelijke formaat om het op een generieke manier te kunnen oversturen. De ontvangende component wil vervolgens weer op zijn eigen specifieke mannier met de ontvangen informatie omgaan. De programmacode die deze noodzakelijke vertaalslagen bewerkstelligt, kan door middel van codegeneratie-technieken automatisch worden gebouwd. Dit proefschrift laat zien hoe, door op een formele manier te beschrijven welke soort informatie de componenten moeten kunnen uitwisselen, een programmabibliotheek kan worden gegenereerd in verschillende programmeertalen. Deze bibliotheken worden vervolgens gebruikt in de diverse componenten om in de brontaal van die component de uit te wisselen gegevens op te bouwen, of te inspecteren. Zenuwstelsel Net zoals een zenuwprikkel in het menselijk lichaam via een stelsel van verbonden zenuwen uiteindelijk de juiste plaats bereikt, moet er ook in een software systeem dat bestaat uit verschillende componenten een soort zenuwstelsel zijn. Dit stelsel, ook wel middleware, of co¨ordinatie-architectuur genoemd, is ervoor verantwoordelijk dat de diverse componenten in een applicatie met elkaar kunnen communiceren. In dit proefschrift wordt intensief gebruik gemaakt van de ToolBus, een programmeerbaar "zenuwstelsel". Deze co¨ordinatie-architectuur zorgt er niet alleen voor dat informatie (in de vorm van een ATerm) wordt overgedragen van de ene naar de andere component, maar doordat de ToolBus programmeerbaar is, kan het gedrag van de communicatie gestuurd worden. Zo kan bepaalde communicatie voorrang krijgen boven andere, ondergeschikt geachte communicatie en bepaalde communicatiepatronen kunnen worden verboden. Verder is het in de ToolBus mogelijk om exact aan te geven of er ´e´en-op-´e´en communicatie moet plaatsvinden tussen componenten, of dat een bepaalde boodschap juist naar iedereen die erin is ge¨interesseerd, moet worden gestuurd. Naast intensief gebruik van de ToolBus in veel van de voorbeelden in dit proefschrift, is ook een discussie opgenomen over mogelijke verbeteringen en uitbreidingen aan dit programmeerbare zenuwstelsel voor software systemen. Bestaande componenten Bij het bouwen van een software systeem, zou telkens de vraag gesteld kunnen worden: "Bestaat dit niet al?". Vaak is het antwoord op deze vraag "Ja, maar . . .", gevolgd door een uitleg waarom een bepaalde, reeds bestaande, component bijna, maar net niet helemaal voldoet. Om toch een bestaande component te kunnen (her-)gebruiken in een software systeem, is het interessant om te kijken hoe, met minimale inspanning, zo’n component toch aan de co¨ordinatie-architectuur gehangen kan worden en hoe de nodige functionaliteit vervolgens aangeboden kan worden aan de rest van de applicatie. In dit proefschrift is specifiek onderzocht hoe twee bestaande en –in de informaticawereld– bekende tekstverwerkingscomponenten "Vim" en "GNU Emacs" kunnen worden ingezet als tekstverwerker voor een programmeeromgeving. Door de voor deze programmeeromgeving noodzakelijke operaties op tekst te defini¨eren, zoals "lees dit bestand in", "ga naar regel X" en "kleur kolom X tot en met Y blauw", ontstaat een interface waaraan alle tekstverwerkers vervolgens moeten voldoen. Voor elk van deze componenten wordt dan de minimale "componentlijm" geprogrammeerd, die nodig is om de component aan deze interface te laten voldoen. Het resultaat is dat een programmeeromgeving ontstaat, waarin mensen hun eigen welbekende tekstverwerker kunnen (her-)gebruiken. Het doel om niet zelf weer zo’n pakket te ontwikkelen en door hergebruik kostenbesparend een software systeem te bouwen, is dan bereikt. Uitbreidbaarheid Een boormachine kan tegenwoordig niet alleen boren, er zijn ook opzetstukken voor te krijgen om allerhande schroeven in te draaien. Evenzo is de PC niet af als hij thuis staat, we kunnen er uitbreidingskaarten (via de PCI bus) insteken, apparaten aanhangen (USB of Firewire), of de ventilatoren ervan vervangen. In software zien we ook steeds meer de wens doorschemeren, om na installatie nog van alles te kunnen veranderen aan het systeem. De plug-ins zijn dan ook al niet meer weg te denken uit internet browsers en muziek- of videoafspeelprogrammatuur. Waar bij de boormachine en PC de uitbreidingsmogelijkheden beperkt zijn, door bijv. voorgeschreven maten, of electronische specificaties, is men in de software nog meer zoekende naar de grenzen van uitbreidingen en veranderingen. Dit proefschrift bestudeert een aantal van deze uitbreidingsarchitecturen en beschrijft hoe zo’n architectuur met behulp van de ToolBus op een structurele wijze kan worden opgezet. Waar het in bestaande systemen soms onduidelijk is wat er moet gebeuren wanneer twee plug-ins op hetzelfde punt in het systeem willen ingrijpen, kan in een programmeerbare co¨ordinatie-architectuur precies worden gespecificeerd wat het gewenste gedrag is. Drempelverlagend Wil hergebruik van componenten bijdragen aan een goedkopere manier van software ontwikkeling, dan zal er alles aan moeten worden gedaan om de integratie en interactie van componenten zo eenvoudig en flexibel mogelijk te laten zijn. Door drempels, die hergebruik van componenten in de weg staan, te verlagen, draagt dit proefschrift bij aan het succesvol bouwen van flexibele software systemen, opgebouwd uit heterogene componenten.

    AB - Hoe bouw je een flexibel software systeem uit reeds bestaande en nieuw te ontwerpen componenten? Hoe wisselen deze componenten onderling relevante gegevens uit? Hoe zorg je ervoor dat deze bundeling van aan elkaar "gelijmde" componenten, ondanks grote onderlinge verschillen (heterogeniteit) in bijv. de gebruikte programmeertaal, leidt tot de gewenste applicatie? Hoe zorg je ervoor dat die applicatie dan ook nog zo flexibel is dat er later nog uitbreidingen en veranderingen aan kunnen worden aangebracht? Dit zijn enkele vragen waar dit proefschrift een antwoord op probeert te geven. Hieronder volgt een samenvatting van de hoofdstukken uit dit proefschrift. Elk van deze hoofdstukken speelt een rol in het bouwen van een flexibel software systeem dat bestaat uit heterogene componenten. Informatie uitwisseling Zodra een software systeem uit twee of meer componenten bestaat, moet ook worden nagedacht hoe deze componenten onderling informatie uitwisselen. Om niet voor elke mogelijke uitwisseling opnieuw te hoeven verzinnen hoe die tot stand moet komen, is het wenselijk hiervoor een algemene oplossing te ontwerpen. In dit proefschrift wordt het ATerm data type beschreven, waarmee op een generieke manier informatie tussen componenten kan worden uitgewisseld. Een belangrijke eigenschap van het ATerm data type is dat ze op een zeer compacte manier kunnen worden gerepresenteerd, zodat zowel bewerkingen op de data, als overdracht van data tussen componenten met minimale inspanning gerealiseerd kan worden. Automatische vertalingen Wanneer applicatie-specifieke informatie in de ene component overgestuurd moet worden naar een andere, gebruikmakend van een generiek uitwisselingsformaat zoals een ATerm, zijn enkele vertaalslagen noodzakelijk. Specifieke informatie in de ene component moet worden vertaald naar het algemeen toegankelijke formaat om het op een generieke manier te kunnen oversturen. De ontvangende component wil vervolgens weer op zijn eigen specifieke mannier met de ontvangen informatie omgaan. De programmacode die deze noodzakelijke vertaalslagen bewerkstelligt, kan door middel van codegeneratie-technieken automatisch worden gebouwd. Dit proefschrift laat zien hoe, door op een formele manier te beschrijven welke soort informatie de componenten moeten kunnen uitwisselen, een programmabibliotheek kan worden gegenereerd in verschillende programmeertalen. Deze bibliotheken worden vervolgens gebruikt in de diverse componenten om in de brontaal van die component de uit te wisselen gegevens op te bouwen, of te inspecteren. Zenuwstelsel Net zoals een zenuwprikkel in het menselijk lichaam via een stelsel van verbonden zenuwen uiteindelijk de juiste plaats bereikt, moet er ook in een software systeem dat bestaat uit verschillende componenten een soort zenuwstelsel zijn. Dit stelsel, ook wel middleware, of co¨ordinatie-architectuur genoemd, is ervoor verantwoordelijk dat de diverse componenten in een applicatie met elkaar kunnen communiceren. In dit proefschrift wordt intensief gebruik gemaakt van de ToolBus, een programmeerbaar "zenuwstelsel". Deze co¨ordinatie-architectuur zorgt er niet alleen voor dat informatie (in de vorm van een ATerm) wordt overgedragen van de ene naar de andere component, maar doordat de ToolBus programmeerbaar is, kan het gedrag van de communicatie gestuurd worden. Zo kan bepaalde communicatie voorrang krijgen boven andere, ondergeschikt geachte communicatie en bepaalde communicatiepatronen kunnen worden verboden. Verder is het in de ToolBus mogelijk om exact aan te geven of er ´e´en-op-´e´en communicatie moet plaatsvinden tussen componenten, of dat een bepaalde boodschap juist naar iedereen die erin is ge¨interesseerd, moet worden gestuurd. Naast intensief gebruik van de ToolBus in veel van de voorbeelden in dit proefschrift, is ook een discussie opgenomen over mogelijke verbeteringen en uitbreidingen aan dit programmeerbare zenuwstelsel voor software systemen. Bestaande componenten Bij het bouwen van een software systeem, zou telkens de vraag gesteld kunnen worden: "Bestaat dit niet al?". Vaak is het antwoord op deze vraag "Ja, maar . . .", gevolgd door een uitleg waarom een bepaalde, reeds bestaande, component bijna, maar net niet helemaal voldoet. Om toch een bestaande component te kunnen (her-)gebruiken in een software systeem, is het interessant om te kijken hoe, met minimale inspanning, zo’n component toch aan de co¨ordinatie-architectuur gehangen kan worden en hoe de nodige functionaliteit vervolgens aangeboden kan worden aan de rest van de applicatie. In dit proefschrift is specifiek onderzocht hoe twee bestaande en –in de informaticawereld– bekende tekstverwerkingscomponenten "Vim" en "GNU Emacs" kunnen worden ingezet als tekstverwerker voor een programmeeromgeving. Door de voor deze programmeeromgeving noodzakelijke operaties op tekst te defini¨eren, zoals "lees dit bestand in", "ga naar regel X" en "kleur kolom X tot en met Y blauw", ontstaat een interface waaraan alle tekstverwerkers vervolgens moeten voldoen. Voor elk van deze componenten wordt dan de minimale "componentlijm" geprogrammeerd, die nodig is om de component aan deze interface te laten voldoen. Het resultaat is dat een programmeeromgeving ontstaat, waarin mensen hun eigen welbekende tekstverwerker kunnen (her-)gebruiken. Het doel om niet zelf weer zo’n pakket te ontwikkelen en door hergebruik kostenbesparend een software systeem te bouwen, is dan bereikt. Uitbreidbaarheid Een boormachine kan tegenwoordig niet alleen boren, er zijn ook opzetstukken voor te krijgen om allerhande schroeven in te draaien. Evenzo is de PC niet af als hij thuis staat, we kunnen er uitbreidingskaarten (via de PCI bus) insteken, apparaten aanhangen (USB of Firewire), of de ventilatoren ervan vervangen. In software zien we ook steeds meer de wens doorschemeren, om na installatie nog van alles te kunnen veranderen aan het systeem. De plug-ins zijn dan ook al niet meer weg te denken uit internet browsers en muziek- of videoafspeelprogrammatuur. Waar bij de boormachine en PC de uitbreidingsmogelijkheden beperkt zijn, door bijv. voorgeschreven maten, of electronische specificaties, is men in de software nog meer zoekende naar de grenzen van uitbreidingen en veranderingen. Dit proefschrift bestudeert een aantal van deze uitbreidingsarchitecturen en beschrijft hoe zo’n architectuur met behulp van de ToolBus op een structurele wijze kan worden opgezet. Waar het in bestaande systemen soms onduidelijk is wat er moet gebeuren wanneer twee plug-ins op hetzelfde punt in het systeem willen ingrijpen, kan in een programmeerbare co¨ordinatie-architectuur precies worden gespecificeerd wat het gewenste gedrag is. Drempelverlagend Wil hergebruik van componenten bijdragen aan een goedkopere manier van software ontwikkeling, dan zal er alles aan moeten worden gedaan om de integratie en interactie van componenten zo eenvoudig en flexibel mogelijk te laten zijn. Door drempels, die hergebruik van componenten in de weg staan, te verlagen, draagt dit proefschrift bij aan het succesvol bouwen van flexibele software systemen, opgebouwd uit heterogene componenten.

    M3 - Phd Thesis 4 Research NOT TU/e / Graduation NOT TU/e)

    PB - Universiteit van Amsterdam

    CY - Amsterdam

    ER -

    Jong, de HA. Flexible heterogeneous software systems. Amsterdam: Universiteit van Amsterdam, 2007. 176 p.