1,328 research outputs found
Incremental Semantic Evaluation for Interactive Systems: Inertia, Pre-emption, and Relations
Although schemes for incremental semantic evaluation have been explored and refined for more than two decades, the demands of user interaction continue to outstrip the capabilities of these schemes. The feedback produced by a semantic evaluator must support the user's programming activities: it must be structured in a way that provides the user with meaningful insight into the program (directly, or via other tools in the environment) and it must be timely. In this paper we extend an incremental attribute evaluation scheme with three techniques to better meet these demands within the context of a modeless editing system with a flexible tool integration paradigm. Efficient evaluation in the presence of syntax errors (which arise often under modeless editing) is supported by giving semantic attributes inertia: a tendency to not change unless necessary. Pre-emptive evaluation helps to reduce the delays associated with a sequence of edits, allowing an evaluator to "keep pace" with the user. Relations provide a general means to capture semantic structure (for the user, other tools, and as attributes within an evaluation) and are treated efficiently using a form of differential propagation. The combination of these three techniques meets the demands of user interaction; leaving out any one does not
A Task-Based Approach to Organization: Knowledge, Communication and Structure
We bridge a gap between organizational economics and strategy research by developing a task-based approach to analyze organizational knowledge, process and structure, and deriving testable implications for the relation between production and organizational structure. We argue that organization emerges to integrate disperse knowledge and to coordinate talent in production and is designed to complement the limitations of human ability. The complexity of the tasks undertaken determines the optimal level of knowledge acquisition and talent. The relations between tasks, namely, complementarities or substitutabilities and synergies, determine the allocation of knowledge among members of the organization. Communication shapes the relation between individual talent, and governs the organizational process and structure that integrates disperse knowledge to perform tasks more efficiently. Organization structure can also be deliberately designed ex ante to correct bias of individual judgement, the extent to which is dependent on the attributes of tasks. Organization process and the routinized organizational structure are the core of organizational capital, which generates rent and sustains organizational growth. This task-based approach enriches the existing body of organization studies, in particular the knowledge-based theory of the firm and the dynamic capabilities theory.task-based approach, complementarities, tacit knowledge, codifiable knowledge, code,vertical communication, horizontal communication, organizational architecture, decision bias
Generating incremental attribute evaluators
In onze maatschappij wordt tegenwoordig veel met software, dat wil zeggen com-
puterprogramma's, gewerkt. Denk daarbij niet alleen aan tekstverwerkers, maar
ook aan software in geldautomaten, videorecorders en het administratiesysteem
van de scus.
Software moet geschreven worden. Programmeurs schrijven software in zoge-
heten hogere programmeertalen, waarvan Pascal, C, Basic, Cobol en Fortran de
bekenste zijn. Zulke programmeertalen nemen tijdrovende, saaie en administratieve
taken verbonden aan het programmeren, uit handen.
Echter, computers \begrijpen" hogere programmeertalen niet, zij moeten ge?n-
strueerd worden in een zogeheten machinetaal. Om een hogere programmeertaal
naar machinetaal te vertalen zijn er speciale computerprogramma's in omloop,
zogeheten compilers. Met andere woorden, compilers vormen een vitale schakel in
het productieproces van software.
Een compiler zet een zogeheten bronprogramma, geschreven in een specieke
hogere programmeertaal, om naar een zogeheten doel programma in een specieke
machinetaal. Men spreek dan bijvoorbeeld ook van een \Pascal compiler voor een
DOS computer". De kwaliteit van het doelprogramma is niet alleen afhankelijk van
de kwaliteit van het bronprogramma, maar ook van de kwaliteit van de gebruikte
compiler.
Compilers zijn grote, ingewikkelde programma's, die ook geschreven moeten
worden. Dit proces wordt ondersteund door compiler-generatoren. Tijdens mijn?192 Samenvatting
boter
melk 30
10 2,50
1,25
item aantal prijs a
b
c
d
1 23 4
b2 b3 x
c2 c3 x
b4+c4 b2+c2
boter
melk 30
10 2,50
1,25
25,00
52,50
item aantal prijs a
b
c
d
1 23 4
40 77,50
a. Invoer b. Uitvoer
Figuur 2. Een rekenblad voor de melkboer
vierjarig onderzoek heb ik een compiler-generator gemaakt. Een compiler-generator
is een computerprogramma dat, na invoer van een minutieuze beschrijving van
een hogere programmeertaal en de gewenste machinetaal, een compiler voor die
programmeertaal genereert.
De voordelen van een compiler-generator zijn legio. Elke verbetering aan de
generator heeft tot gevolg dat elke gegenereerde compiler verbetert. Bovendien
worden de produktiekosten en de produktietijd verbonden aan het maken van een
compiler, aanzienlijk verminderd. Immers, in plaats van een compiler voor een
hogere programmeertaal hoeft alleen nog maar een beschrijving van die hogere
programmeertaal geschreven te worden. Een student informatica kan in een paar
maanden tijd een compiler genereren, terwijl een groep beroeps programmeurs daar
eerder vele maanden tot jaren mee bezig is.
Incrementele berekeningen
De kracht van de compilers gegenereert door dedoor mij ontwikkelde generator is
voornamelijk gelegen in het feit dat ze incrementeel zijn. Dat betekent dat na een
kleine verandering in het bronprogramma, de compiler de corresponderende veran-
deringen in het doelprogramma aanbrengt|dit in tegenstelling tot het simpelweg
vertalen van het gehele (gewijzigde) bronprogramma. Dit laatste zou veel meer
tijd zou kosten.
Wat een incrementele berekening is wordt elegant ge?llustreerd aan de hand van
een compiler-verwante toepassing: een rekenblad of spreadsheet. Een rekenblad
bestaat uit cellen in een rechthoekig patroon, zie Figuur 2a. Elke cel wordt
aangeduid met een letter-cijfer combinatie. Zo wordt de cel links-boven aangeduid
met a1. Een cel kan tekst, getallen of formules bevatten: cel a1 bevat de tekst
`item', cel b2 bevat het getal 10 en cel b4 bevat de formule b2 b3.
Een rekenblad-evaluator berekent de waarde van de cellen waar formules in
staan. Dus, na invoer van het rekenblad in Figuur 2a wordt de uitvoer van Figuur 2b
geproduceerd.
Stel dat we een verandering aanbrengen in het rekenblad; we voeren een
zogeheten edit-operatie uit. We verlagen het getal in cel b2 van 10 naar 9, zie?Informele inleiding 193
boter
melk 30
2,50
1,25
item aantal prijs a
b
c
d
1 23 4
b2 b3 x
c2 c3 x
b4+c4 b2+c2
9 boter
melk 30
2,50
1,25 52,50
item aantal prijs a
b
c
d
1 23 4
9 22,50
75,00 39
a. Wijziging in de invoer b. Zuinige herberekening
Figuur 3. Wijziging aan een rekenblad
Figuur 3a. De rekenblad-evaluator zou alle cellen met formules opnieuw kunnen
uitrekenen. Een incrementele evaluator berekent alleen de grijze cellen in Figuur 3b.
In dit geval spaart dat de berekening van cel c4 uit.
Het is overigens niet eenvoudig om in te zien welke cellen herberekend moeten
worden. Om dat te bepalen stelt de rekenblad-evaluator een zogeheten graaf op
die de cel-afhankelijkheden weergeeft. Een knoop in de graaf representeert een cel.
Er loopt een pijl van knoop b2 naar knoopb4 omdat de formule van cel b4 refereert
aan cel b2. Zo'n pijl impliceert dat cel b4 na celb2 uitgerekend moet worden.
Bij een incrementele evaluatie moet elke cel wiens knoop in de graaf een
opvolger is van b2, herberekend worden, tenzij veranderingen eerder uitdoven.
Als voorbeeld van dat laatste, beschouwen we de volgende verandering: de prijs
van boter gaat naar 0,25 en de hoeveelheid boter naar 100. In dat geval blijft de
waarde van cel b4 25,00 zodat d4 niet herberekend hoeft te worden. Grafen spelen
b3
b2
c2
c3
c4
d2
b4
d4
bij incrementele berekeningen een belangrijke rol. Ze komen dan ook veelvuldig in
dit proefschrift voor.
Compilers worden ook vaak toegepast op slechts weinig veranderde invoer. Hoe
vaak wordt een computerprogramma niet gecompileerd om er vervolgens achter te
komen dat er een kleine fout in staat? Het is daarom jammer dat er nog zo weinig i:=1 had natuurlijk
i:=0 moeten zijn. incrementele compilers zijn.
Taal-specieke editors
Een editor is een computerprogramma waarmee gegevens in een computer in-
gevoerd kunnen worden. Bovendien kunnen met een editor bestaande gegevens
gewijzigd worden. Meestal verstaat men onder een editor een algemeen programma
waarmee gegevens voor uiteenlopende applicaties (toepassings programma's zoals
compilers, rekenbladen, tekstverwerkers) ingevoerd kunnen worden.
Een applicatie-specieke editor is een invoer-en-wijzig programma dat \kennis"
heeft van een applicatie. Alle huis-tuin-en-keuken applicaties zoals tekstverwerkers L a T E X is geen huis-tuin-
en-keuken applicatie. en rekenbladen zijn uitgerust met applicatie-specieke editors. Het grootste voor-
deel van zulke editors is dat ze de gebruiker kunnen sturen: er kan geen al te grote
onzin in worden gevoerd.?194 Samenvatting
Compilers zouden ook uitgerust kunnen worden met een brontaal-specieke
editor. Dat is met name interessant als er een incrementele compiler beschikbaar
is die tijdens het intypen van het bronprogramma voortdurend het bijbehorende
doelprogramma berekend. Zulke systemen zouden de arbeidsproduktiviteit van
programmeurs enorm verhogen. Immers, fouten in het bronprogramma worden
direct als zodanig herkend door het system, en meegedeeld aan de gebruiker. Het
grootste voordeel is echter dat de editor \ondervraagd" kan worden over bepaalde
kenmerken van het bronprogramma. Voor ingewijden: als de editor constateert dat
i:=1 incorrect is omdat i niet gedeclareerd is kan het een menu aanbieden met alle
integer variabelen in de huidige scoop en een optie om de declaratie i:integer
toe te voegen aan de declaraties.
Kort overzicht
Dit proefschrift beschrijft de generatie van incrementele compilers, met name als
onderdeel van een taal-specieke \language based" editor.
Omdat we uitgaan van een taal-specieke editor, kunnen we het ontleed-
traject (lexical scanning en parsing ) overslaan: de editor onderhoudt een boom-
representatie van het ingevoerde programma. Dat betekent dat compileren niets De titel: Generating
incremental attribute
evaluators.
anders is dan het attribueren van de boom; de compiler is een (incrementele)
attribute evaluator.
Het formalisme waarmee we bomen en attributen beschrijven is het attribuut
grammatica formalisme.
We geven twee methodes om incrementele attribuut evaluatoren te construeren.
De eerste methode is een bestaande: visit-sequences sturen boom decoratie. De
tweede methode is nieuw: visit-sequences worden afgebeeld op visit-functies die
gecached worden om incrementeel gedrag te verkrijgen. Een complicatie bij deze
aanpak vormen zogeheten intra-visit-dependencies. Om dat probleem op te lossen
worden bindingen ge?ntroduceerd.
Visit-functies zijn functies zonder zij-eecten. Dit opent de mogelijkheid tot
allerhanden optimalizaties. Aan de orde komen splitting, elimination, unication,
folding, normalization en untyping.
We bespreken hoe visit-sequences berekend worden aan de hand van een gram-
matica. We wijzigen Kastens' ordered scheduling op twee vlakken. Om te beginnen
voeren we dat grafen in (in stap 4) waardoor een grotere klasse van gramatica's
geaccepteerd wordt. Ten tweede voeren we een nieuw orderings algorithme in
(chained scheduling ) dat visit-sequences berekent die beter geschikt zijn voor
omzetting naar visit-functies.
Een groot deel van het onderzoek heeft zich toegespitst op de haalbaarheid van
een functionele aanpak: we hebben een generator geschreven. De gegenereerde
evaluatoren zijn eenvoudig, elegant en robuust. Bovenal zijn ze snel. De generator
is onder andere gebruikt om een deel van zichzelf te genereren
One-pass transformations of attributed program trees
The classical attribute grammar framework can be extended by allowing the specification of tree transformation rules. A tree transformation rule consists of an input template, an output template, enabling conditions which are predicates on attribute instances of the input template, and re-evaluation rules which define the values of attribute instances of the output template. A tree transformation may invalidate attribute instances which are needed for additional transformations.\ud
\ud
In this paper we investigate whether consecutive tree transformations and attribute re-evaluations are safely possible during a single pass over the derivation tree. This check is made at compiler generation time rather than at compilation time.\ud
\ud
A graph theoretic characterization of attribute dependencies is given, showing in which cases the recomputation of attribute instances can be done in parallel with tree transformations
Contributions to the Construction of Extensible Semantic Editors
This dissertation addresses the need for easier construction and extension of language tools. Specifically, the construction and extension of so-called semantic editors is considered, that is, editors providing semantic services for code comprehension and manipulation. Editors like these are typically found in state-of-the-art development environments, where they have been developed by hand. The list of programming languages available today is extensive and, with the lively creation of new programming languages and the evolution of old languages, it keeps growing. Many of these languages would benefit from proper tool support. Unfortunately, the development of a semantic editor can be a time-consuming and error-prone endeavor, and too large an effort for most language communities. Given the complex nature of programming, and the huge benefits of good tool support, this lack of tools is problematic. In this dissertation, an attempt is made at narrowing the gap between generative solutions and how state-of-the-art editors are constructed today. A generative alternative for construction of textual semantic editors is explored with focus on how to specify extensible semantic editor services. Specifically, this dissertation shows how semantic services can be specified using a semantic formalism called refer- ence attribute grammars (RAGs), and how these services can be made responsive enough for editing, and be provided also when the text in an editor is erroneous. Results presented in this dissertation have been found useful, both in industry and in academia, suggesting that the explored approach may help to reduce the effort of editor construction
Well-Formed and Scalable Invasive Software Composition
Software components provide essential means to structure and organize software effectively. However, frequently, required component abstractions are not available in a programming language or system, or are not adequately combinable with each other. Invasive software composition (ISC) is a general approach to software composition that unifies component-like abstractions such as templates, aspects and macros. ISC is based on fragment composition, and composes programs and other software artifacts at the level of syntax trees. Therefore, a unifying fragment component model is related to the context-free grammar of a language to identify extension and variation points in syntax trees as well as valid component types. By doing so, fragment components can be composed by transformations at respective extension and variation points so that always valid composition results regarding the underlying context-free grammar are yielded. However, given a language’s context-free grammar, the composition result may still be incorrect.
Context-sensitive constraints such as type constraints may be violated so that the program cannot be compiled and/or interpreted correctly. While a compiler can detect such errors after composition, it is difficult to relate them back to the original transformation step in the composition system, especially in the case of complex compositions with several hundreds of such steps. To tackle this problem, this thesis proposes well-formed ISC—an extension to ISC that uses reference attribute grammars (RAGs) to specify fragment component models and fragment contracts to guard compositions with context-sensitive constraints. Additionally, well-formed ISC provides composition strategies as a means to configure composition algorithms and handle interferences between composition steps.
Developing ISC systems for complex languages such as programming languages is a complex undertaking. Composition-system developers need to supply or develop adequate language and parser specifications that can be processed by an ISC composition engine. Moreover, the specifications may need to be extended with rules for the intended composition abstractions.
Current approaches to ISC require complete grammars to be able to compose fragments in the respective languages. Hence, the specifications need to be developed exhaustively before any component model can be supplied. To tackle this problem, this thesis introduces scalable ISC—a variant of ISC that uses island component models as a means to define component models for partially specified languages while still the whole language is supported. Additionally, a scalable workflow for agile composition-system development is proposed which supports a development of ISC systems in small increments using modular extensions.
All theoretical concepts introduced in this thesis are implemented in the Skeletons and Application Templates framework SkAT. It supports “classic”, well-formed and scalable ISC by leveraging RAGs as its main specification and implementation language. Moreover, several composition systems based on SkAT are discussed, e.g., a well-formed composition system for Java and a C preprocessor-like macro language. In turn, those composition systems are used as composers in several example applications such as a library of parallel algorithmic skeletons
Fairness-aware Machine Learning in Educational Data Mining
Fairness is an essential requirement of every educational system, which is reflected in a variety of educational activities. With the extensive use of Artificial Intelligence (AI) and Machine Learning (ML) techniques in education, researchers and educators can analyze educational (big) data and propose new (technical) methods in order to support teachers, students, or administrators of (online) learning systems in the organization of teaching and learning. Educational data mining (EDM) is the result of the application and development of data mining (DM), and ML techniques to deal with educational problems, such as student performance prediction and student grouping. However, ML-based decisions in education can be based on protected attributes, such as race or gender, leading to discrimination of individual students or subgroups of students. Therefore, ensuring fairness in ML models also contributes to equity in educational systems. On the other hand, bias can also appear in the data obtained from learning environments. Hence, bias-aware exploratory educational data analysis is important to support unbiased decision-making in EDM.
In this thesis, we address the aforementioned issues and propose methods that mitigate discriminatory outcomes of ML algorithms in EDM tasks. Specifically, we make the following contributions:
We perform bias-aware exploratory analysis of educational datasets using Bayesian networks to identify the relationships among attributes in order to understand bias in the datasets. We focus the exploratory data analysis on features having a direct or indirect relationship with the protected attributes w.r.t. prediction outcomes.
We perform a comprehensive evaluation of the sufficiency of various group fairness measures in predictive models for student performance prediction problems. A variety of experiments on various educational datasets with different fairness measures are performed to provide users with a broad view of unfairness from diverse aspects.
We deal with the student grouping problem in collaborative learning. We introduce the fair-capacitated clustering problem that takes into account cluster fairness and cluster cardinalities. We propose two approaches, namely hierarchical clustering and partitioning-based clustering, to obtain fair-capacitated clustering.
We introduce the multi-fair capacitated (MFC) students-topics grouping problem that satisfies students' preferences while ensuring balanced group cardinalities and maximizing the diversity of members regarding the protected attribute. We propose three approaches: a greedy heuristic approach, a knapsack-based approach using vanilla maximal 0-1 knapsack formulation, and an MFC knapsack approach based on group fairness knapsack formulation.
In short, the findings described in this thesis demonstrate the importance of fairness-aware ML in educational settings. We show that bias-aware data analysis, fairness measures, and fairness-aware ML models are essential aspects to ensure fairness in EDM and the educational environment.Ministry of Science and Culture of Lower Saxony/LernMINT/51410078/E
Proceedings of the 2011 Joint Workshop of Fraunhofer IOSB and Institute for Anthropomatics, Vision and Fusion Laboratory
This book is a collection of 15 reviewed technical reports summarizing the presentations at the 2011 Joint Workshop of Fraunhofer IOSB and Institute for Anthropomatics, Vision and Fusion Laboratory. The covered topics include image processing, optical signal processing, visual inspection, pattern recognition and classification, human-machine interaction, world and situation modeling, autonomous system localization and mapping, information fusion, and trust propagation in sensor networks
- …