Student Colloquium Presentation Abstracts
Extending the Java Programming Language with Generators
Speaker: Jonathan Guzman Carmona
Abstract: The Java programming language is a portable tool to create applications in a variety of domains. The language has evolved to a mature level where a wide range of applications can be created. Still some proposals exist to extend the language in order to make it easier to develop and implement applications. Many extensions have been implemented using several program transformation techniques such as Domain Specific Languages (DSLs), extending existing compilers, assimilating language extensions, intermediate code transformation and strategy rewriting frameworks. One extension that has not yet been implemented in the Java language but that is native in dynamic languages is generators. In this report we will introduce generators and discuss several existing solutions and examples in the context of program transformation and extension of programming languages. Finally we will evaluate these solutions and techniques from the perspective of its applicability and feasibility to extend the Java programming language with the generator construct within a commercial setting.
Integration of HTTP Push with a JSF AJAX framework
Speaker: Engin Bozdag
A new breed of web application, dubbed AJAX, is emerging in response to a limited degree of interactivity in large-grain stateless Web interactions. However, AJAX still suffers from the limitations of the Web’s request/response (pull) architecture. This prevents servers from “pushing” real-time alerts such as market
data, news headlines or auction updates. Several libraries, such as Cometd and DWR bring push support to existing AJAX applications. It is a known fact that these libraries will cause scalability problems in most web application servers. However, there has been no empirical study conducted to ﬁnd out the actual trade-offs of applying push on browser-based or AJAX applications and comparing it with a pull approach. The integration of the mentioned libraries with existing AJAX frameworks is also far from trivial. During this presentation we will ﬁrst introduce a comparison of two free open-source push libraries. Later, we will present the results of an empirical study that compares push and pull approaches in terms of scalability, network usage and latency. Finally we will show how current push solutions can be integrated with an AJAX framework that is based on Java Server Faces (JSF) architecture by providing several extensions and sample applications.
Software Factories for a Service Oriented Architecture
Speaker: Gerardo de Geest
Modern distributed applications are based on the design principles of a Service Oriented Architecture (SOA). This architecture is based on the consideration of having multiple services spread all over the world,
while still communicating with each other. Currently the development of these services is still done in general purpose languages like C\# and Java.
Because there are so many services needed to be developed these days, it is hard for modern IT companies to handle all the requests they get from their customers. It is therefore necessary to consider other ways for
the repetitive development of services. These services might be different from each other, but they also have a lot in common.
This presentation gives an overview of the approaches that have been proposed or implemented to create a more efficient way of developing a service using the model-driven software development paradigm. In particular, the survey will focus on the Software Factories camp, which is one of the many approaches of the Model-Driven Software Development paradigm.
Model-driven development, deployment and maintenance of web applications
Speaker: Jonathan Joubert
Model-Driven Engineering (MDE) aids designing software at a conceptual level, making generating and maintaining code easier. However, few tools support development after code generation. This study researches the use of MDE in web application development. The main challenge herein lies in modeling business logic and generating 100% of the application code. Another challenge lies in modeling the many details of web development and providing an abstraction to the life cycle of web development itself. Also, for end users, creating a non-trivial web application is largely impossible, due to the lack of tool support. The study proposes the development of a tool that deals with the concerns found.
A Domain-Specific Language for Computer Games
Speaker: Jeroen Dobbe
The development of computer games is currently done by using ad hoc development methods and using middleware and tools that are not particularly well suited for supporting every members of a game development team in their day to day work. Some members of the development team have established helpful development tools, while others are lacking any support whatsoever.
This literature study is aimed at finding the current bottlenecks and the paradigm (way of thinking) used when it comes to specifying games. This information will provide a solid basis to start defining and implementing a domain-specific programming language that will further advance the current state of tools that are being used in the game industry. The domain-specific language will, of course, be aimed mostly at the part of a game that need the most programming: game design (e.g. objects, rules and interaction).
In this literature study I will discuss domain-specific languages, game
development and the possible applications of domain-specific languages to game development. Some considerations when it comes to the type of language to be defined and implemented to support the developers as much as possible will also be discussed.
Towards an Infrastructure for Empirical Software Measurements
Speaker: Eric de Backer
Software measurement research is a special type of empirical research which is empirical research on the software itself. Eventually this kind of research can be automated, however, the creation of an environment to automate a software measurement experiment is a time consuming task. It is believed that this task can be generalized to an infrastructure which supports the user in the setup of the experiment environment. In this presentation we will discuss the preparation of the development of such an infrastructure. This includes an overview of empirical research in software engineering and the development of an initial prototype for the infrastructure.
Speaker: Robin van der Rijst
Software evolution is the process of adapting and extending software systems to ﬁx bugs and cope with changing requirements and environments. Modularization is essential in dealing with complexity in current software systems and making evolution easier. OOP however, suffers from the tyranny of dominant decomposition. This means that no matter how well-modularized the system is, there will always be functionality that is scattered throughout the application and tangled with the primary functionality of the modules, called Crosscutting Concerns (CCCs). Aspect-oriented programming (AOP) aims to improve modularity by providing constructs to modularize CCCs: aspects. Aspects can be introduced into existing OOP systems using refactoring in two steps. First CCCs in existing code must be identified, a process called aspect mining. The second step is the extraction of the identiﬁed CCCs from the OO code to aspects using aspect-
introducing refactoring. For aspect mining, several existing tools and techniques are available. For aspect extraction, however, there is very little tool support and only a few techniques. Another problem is inconsistent granularity of mining results and refactoring techniques. CCC sorts can be used to solve this problem.
Push Solutions for AJAX Technology
Speaker: Engin Bozdag
and XML) is emerging in response to the limited degree of interactivity in large-grain stateless Web interactions. The intent is to make web pages feel more responsive by exchanging small amounts of
data with the server behind the scenes and making changes to individual user interface components. However, AJAX alone does not address instant messengers, stock tickers, or other collaborative applications that require ’push’ data streaming. Today, these types of applications are usually implemented using a client-pull style, and the client component actively requests the state changes using client-side timeouts.An alternative to this is push-based style, where the server broadcasts the state changes to the clients asynchronously every time its state changes. In this presentation we will be discussing the fundamental limits of browser-based applications and techniques in order to achieve a real-time event notification. We will be comparing HTTP based push with several other techniques. We will also compare push models from the literature with the solutions from the software industry.
Chain monitoring for Web Services
Speaker: Bobby Bregman
This Master Thesis describes an implementation and realization of Chain
monitoring for Web Services for Fortis Insurances Netherlands. Through a
detailed definition of the assignment the problem definition is described in
detail. This forms a basis to describe and make an inventory of the factors
that are of importance for the approach to be taken to implement and realize
a solution for the problem definition. The iterative approach cuts the
implementation and realization into the iterations event-generation,
event-collection and event-monitoring. Requirements engineering and
management is applied in the realization of the Literature study, Functional
Design and Technical Design.
The concepts that have been implemented and realized for the generation and
collection of health information about chains of Web Services are Aspect
Oriented Programming, Java Management eXtensions and Windows Management
Instrumentation. Through a number of different web-enabled views this health
information is made available for the monitoring of chains of Web Services.
The actual chain monitoring is implemented and realized through the
application of the concept Web Services Composition.
Application of above described approach and concepts onto the given problem
definition has delivered a good end result within Fortis Insurances
Netherlands. The used approach and chosen concepts are not specifically
pointed on this problem or the Fortis Insurances Netherlands organization or
Bio-SPHERE, a distributed multimodal biometric platform
Speaker: Maurits Hartman
Biometrics provide for superior security as opposed to traditional means, such as passwords.
The Bio-SPHERE project at the Computer Science department at Valladolid University aims
to create a scalable, secure and multimodal biometric platform for applications that require biometric
functionality. The platform will be made up by several networked computing devices, each running Linux.
A Bio-SPHERE application on each device maintains a connection with the Bio-SPHERE network.
The application interfaces with possible biometric hardware, handles persistent storage of biometric
data and offers biometric functions to client applications.
The network is designed to support a heterogeneous mix of devices, each offering a subset of
the previously mentioned capabilities.
In this talk we present and motivate the requirements and architecture of the platform.
Generating system documentation augmented with traceability information, using a central XML-based repository
Speaker: Thomas Kraus
Documentation of many (software) systems built in industry is often
insufficient, incomplete, or sometimes not even present at all. Documentation here means a set of requirements documents, architectural overview, design document and test-case descriptions.
Various tools for management of requirements and design artefacts are
available (both commercial and open source), but each one has its own disadvantages. This results in a lot of companies
writing all of their documentation in MS Word or equivalents, which has a
number of disadvantages, too.
The Forest Project at Chess, a medium-sized software and electronics company
in Haarlem, proposes an XML-based repository in which all requirements and
(architectural) design information can be stored, which serves two purposes. Firstly, the repository can be used to generate
documentation about a system. Secondly, the repository shall support tracing
of requirements to assess the completeness of a system and to allow for analysis of the impact of proposed changes to a system.
During this presentation I will present the results of my literature study,
which was done in preparation of my Master's Thesis project. During my Thesis project, I shall build a prototype plug-in for the Eclipse IDE, which allows for documentation generation combined with requirements traceability. This way, documentation becomes integrated with the implementation of a system.
From UML diagrams to behavioural source code
Speaker: Sabrina Jim
Mijn presentatie gaat over het automatisch genereren van UML modellen naar broncode die niet meer aangepast hoeft te worden. De complexiteit van dit onderzoek zit hem in het genereren van broncode uit gedragsdiagrammen. Dit komt doordat de gedragsdiagrammen niet per se een één op één mapping hebben met de broncode, gemodelleerd gedrag hoeft niet zichtbaar in code voor te komen als expliciete statements, gemodelleerd gedrag kan op meerdere manieren geïnterpreteerd worden en de mapping tussen gedrags- en structuurdiagrammen is niet altijd duidelijk.
In mijn onderzoek heb ik een manier gevonden om deze problemen op te lossen, namelijk door het definiëren van een UML profiel. Tijdens de presentatie zal ik het UML profiel ook bespreken.