|
|
Generating implementation from system requirements
Franců, Jan ; Hnětynka, Petr (advisor)
Designing a software system starts with writing the system requirements. Typically, these requirements are expressed in UML and contain use cases and domain model. A use case is a sequence of tasks which have to be done to achieve one of the system's goals. These tasks are written in natural language (English). The domain model (typically captured in a class diagram) describes used objects and their relations. The goal of the thesis is to analyze, whether the system requirements are su±cient for generating an implementation model, which will manage communication between the system's components. The generated model might be used for future development and can be used for testing the users interactions. A prototype implementation of the generator is expected.
|
|
|
SOFA 2 runtime support for dynamic languages
Keznikl, Jaroslav ; Malohlava, Michal (advisor) ; Hnětynka, Petr (referee)
Component systems allow to build large scale applications from reusable components. However, many of the contemporary component systems have an extensive component development cycle with a long turnaround time. To speed up the component development, the dynamic languages, which allow to change the implementation at runtime without compilation and restarting, could be used. Therefore, the support of components implemented in dynamic languages could simplify development of application prototypes and add other advantages of interpreted dynamic languages (dynamic typing etc.). The aim of this thesis is to extend the SOFA 2 component system runtime to support primitive components implemented in dynamic languages. The extension is based on the SOFA 2 component aspect mechanism and it focuses on minimal changes of the existing core runtime implementation. The presented implementation also provides tools for interaction with running scripted components in order to allow dynamic implementation changes. On the basis of this extension, the thesis evaluates potential of the SOFA 2 microcomponent-based controller part for building runtime extensions, particularly extensions integrating new runtime technologies such as dynamic languages.
|
|
|
Migration and load-balancing in distributed hierarchical component systems
Remeš, Václav ; Hnětynka, Petr (advisor) ; Bureš, Tomáš (referee)
A well balanced usage of resources is one of the goals of distributed applications. A way to achieve such a balanced usage is by run-time monitoring and migration of components of already executed applications between computers. There are many issues related to migration, from monitoring resources usage till obtaining component state and transferring to a di erent computer. The goal of this thesis is to design and implement a support for migration and load-balancing of components in the SOFA 2 hierarchical component system.
|
|
|
Deployment of SOFA 2 applications for embedded environment
Pastorek, Jaroslav ; Hnětynka, Petr (advisor) ; Malohlava, Michal (referee)
Development of applications for embedded devices is a daunting task particularly due to the diversity of used hardware. Technologies like Java ME attempt to provide unified programming model in the spirit of slogan "write once - run anywhere"; however the platform specifics still linger. Applications for embedded devices could therefore benefit from the use of component - based development where platform - specific parts can be separated into well - defined easily replaceable components. The goal of this thesis is to analyze the current deployment process for the component applications written using SOFA 2 component system and propose changes that would allow such applications to be deployed in Java ME environment, particularly CLDC configuration with MIDP profile. The proposed solution is based on transformation of SOFA 2 component application into MIDlet application. This transformation includes pregeneration of code for static instantiation of components which is normally done dynamically by interpreting component descriptions. The result of the transformation is standalone MIDlet package that contains all necessary code - this includes adjusted component runtime and components themselves. The development process of SOFA 2 applications is also adjusted to support new deployment process.
|
|
|
Cloud computing using a hierarchical component system
Kučera, Tomáš ; Hnětynka, Petr (advisor) ; Kofroň, Jan (referee)
Cloud computing is nowadays a popular computing paradigm. Computers are interconnected via network and jointly offer a lot of computing performance. SOFA 2 is a hierarchical component system offering a distributed run-time environment; therefore, it is a suitable environment for cloud computing. Applications are composed from components; each component may run on different computer in the `cloud'. The deployment of the components influences the overall performance of the application and the utilization of resources in the `cloud'; therefore, it has to be planned carefully. In this thesis, an algorithm for automated deployment planning of hierarchical component-based applications is proposed and further implemented in the SOFA 2 system. The algorithm incorporates components' demands and machines' resources in order to maximize performance of the deployed applications. The thesis also proposes and implements extensions that allow using the SOFA 2 component system as an actual cloud platform.
|
|
|
Supporting multiplatform applications with YA-RPC
Kovařík, František ; Hnětynka, Petr (advisor) ; Yaghob, Jakub (referee)
Title: Supporting multiplatform applications with YA-RPC Author: František Kovařík Department: Department of Software Engineering Supervisor: RNDr. Petr Hnětynka, Ph.D. Supervisor's e-mail address: hnetynka@d3s.mff.cuni.cz Abstract: Over the last three decades, Remote Procedure Call (RPC) has become a popular inter-computer and inter-process communication paradigm widely used by a variety of interconnected computer systems. Even though a number of RPC protocols and implementations evolved over those years, no single system offers a significant set of features, while providing an easy-to-use application programming interface. In this thesis, we present Yet Another Remote Procedure Call - YaRpc, a specification of a flexible and programmer friendly middleware that offers advanced features such as pluggable transports and protocols, callbacks, and configurable method dispatch. Additionally, we define YaRpc Native Protocol (YNP), a new light-weight high-performance RPC protocol with a rich set of features. We provide a native implementation of both YaRpc middleware and YNP protocol for Java and .NET Framework, and compare its usability with Java RMI, .NET Remoting and SOAP web services. Keywords: YaRpc, remote procedure call, distributed system
|
|
|
Annotation-driven development of software components
Klesnil, Jan ; Nečaský, Martin (referee) ; Hnětynka, Petr (advisor)
Annotation-based development is a programming technique which is recently gaining on popularity. The thesis examines ways in which this technique can be applied to development of component applications. Aim of the the thesis was to design a model of run-time annotations for SOFA 2. The annotations are used at run-time phase of application's development cycle to bind, control execution and dynamically update a component. Implementation of the proposed solution is based on standard Java annotations. Further, the thesis proposed a way in which these annotations can be extended to other phases of application's development cycle. The thesis proposes and implements a solution to dynamic update of a basic type of software components. The dynamic update is a process that changes code of a component without suspending the whole component application.
|
|
|
Interoperability between component-based and service-oriented systems
Mašek, Karel ; Hnětynka, Petr (advisor) ; Parízek, Pavel (referee)
The component-based and service-oriented development have become commonly used techniques for building high quality, evolvable, large systems in a timely and affordable manner. In this setting, interoperability is one the essential issues, since it enables the composition of heterogeneous components and services. The aim of the thesis is to analyze possibilities of interoperability between the SOFA2 component system and the OSGi Service Platform, and based on that propose and implement a solution for mutual collaboration. The actual integration is based on the use of aspects and annotations. The issues connected with the runtime service management (e.g. binding/unbinding services) are handled by the control part of components using the aspects. While, the annotations serve for specifying service-enabled SOFA2 components in a declarative way. The OSGi support is incorporated in both the SOFA2 runtime environment and the tool for developing SOFA2 components. Furthermore, the outlined approach is general and can be easily reused for integrating other SOA-based systems as well.
|
|
|
Deployment Planner for Heterogeneous Component-based Applications
Urban, Jaroslav ; Hnětynka, Petr (referee) ; Bulej, Lubomír (advisor)
Deployment of component applications is the process of making them available for further use by clients. The OMG Deployment & Conguration Speci cation aims at creating a uni ed deployment process independent of component models. We use the OMG speci cation to create a deployment framework able to deploy heterogeneous component applications which are implemented using multiple component models. This work focuses on the planning phase of the speci cation, which selects computer resources for components with respect to their requirements. We have implemented the planning phase via a graphical user interface utilizing an automated planning algorithm which assists the user in creating a valid planning. The planning tools are extensible to support additional technologies, component models and more advanced planning heuristics.
|
|
|
Translating Ruby to PHP
Majda, David ; Hnětynka, Petr (referee) ; Bednárek, David (advisor)
The goal of the work is to design and implement a compiler translating a signi cant subset of the Ruby language into PHP, with emphasis on the correct translation of dynamic and functional language elements and compatibility with the original Ruby language implementation. The work begins with an introduction of the Ruby language and an overview of its existing implementations, highlighting their interesting properties. The work then focuses on analysis of the individual language elements' properties and a description of their translation to PHP. Detailed overview of the implemented constructs and standard library elements is attached. The result of the work is practically usable compiler that can be further extended and used in the production environment after implementing remaining Ruby language elements.
|
guest ::
