• Refine Query
  • Source
  • Publication year
  • to
  • Language
  • 35
  • 7
  • 3
  • 2
  • 2
  • 1
  • 1
  • 1
  • 1
  • 1
  • Tagged with
  • 59
  • 59
  • 59
  • 39
  • 27
  • 23
  • 18
  • 13
  • 13
  • 12
  • 12
  • 12
  • 11
  • 11
  • 10
  • About
  • The Global ETD Search service is a free service for researchers to find electronic theses and dissertations. This service is provided by the Networked Digital Library of Theses and Dissertations.
    Our metadata is collected from universities around the world. If you manage a university/consortium/country archive and want to be added, details can be found on the NDLTD website.
1

Component-based Application Generator : A Designing Methodology for Application Construction

Wang, Chen-Yi 05 July 2004 (has links)
Component-based software is finally taking off in a big way and component-based application generators have been championed because they can be used to shorten a system¡¦s development cycle and therefore lower its development costs. Component-based application generators are standardardized building blocks that can be used to assemble, rather that develop, information systems (IS). This paper presents a component-based application generator in the restaurant food ordering setting and a requirement modeling methodology for IS construction based on the generator presented. A prototype was assembled using the generator and methodology presented to illustrate the concepts and application. With this approach, system developers or end users can more easily build, modify and maintain their applications.
2

A methodology for component-based user interface modeling with UML

Cheng, Chih-Hsiung 12 July 2004 (has links)
User interface (UI) has become the key element of modern information systems (ISs) and is commonly viewed as one of the decisive factors for the success of an IS project. Many component-based development tools have been introduced by software vendors to meet the needs of designing a variety of UIs. Such modern design tools offer system developer vehicles to create sophisticated UIs with a few codes. However, the modeling methodology from the stages of user requirement modeling to UI modeling based on the modern design tools is virtually lacking. This study presents an integrated modeling methodology, which integrates the unified modeling language with interface drawing and interface glossary to provide a seamless and graphical approach and specifications for component-based UI modeling from user requirement modeling. A real-world case using the integrated approach is presented and a prototype system is developed to illustrate the concepts, application, and the advantages of using the proposed methodology.
3

Component Modeling Methodology¡GA UML Based Tools Approach

Chen, Hong-Ming 12 June 2003 (has links)
Due to the fact that the environment which business confront is very dynamic, so the business require the software to reduce the response time, provide the high quality, and supply the flexible modeling process and high maintainability. In order to meet the requirement, a new software solution is emerged. Component-based software engineering is a method to integrate existed component to produce faster speed, lower cost and higher quality software. And it is concerned with the rapid assembly of systems from components where components and frameworks have certified properties; and these certified properties provide the basis for predicting the properties of systems built from components. Therefore, component based software engineering replace the position belong to traditional software engineering progressively, it become the next generation software engineering paradigm. Because businesses want to transform their requirement to be final components, so the component-based software engineering must have component modeling methodology in the system analysis stage. For this reason, the advantage and disadvantage of the component modeling methodology makes a very deep influence on component-based software engineering. And after the survey we made, we discover the greater parts of the existed component modeling methodology have a lot of defects, for example: the modeling method stay at abstract level, lack of clear and definite modeling rules, short of consistence of process document and can¡¦t meet the good component modeling characteristics. Fortunately, in our surveyed methodology, we discover the ¡§UML Component¡¨ is a component modeling methodology which can meet the good component modeling characteristics and have the develop potential. But the ¡§UML Component¡¨ methodology still has some problem, for example: lack of explicit component identify rules, complete tools support and simply modeling process. Due to these reasons, our study provides three solutions to refine and extend the ¡§UML Components¡¨ methodology. First of all, we utilize the use case identify method by [§d¤¯©M2002]¡Bthe concept of ¡§Fan-in and Fan-out¡¨ by [Marquis2002] and the use case association transform method to refine the problem of component modeling rules. Secondly, we employ data glossary, data relation matrix and operation reference matrix to improve the problem of component modeling tools. Finally, we redesign the process model which includes four stages as follows, requirement acquisition, component identification, component interaction and component specification to resolve the irrational parts of original modeling process. With this refined methodology, the system analysts can follow the stand modeling rules and process. In the other hand, the system developer also can develop the system which meet the business requirement exactly, ensure the component quality and speed up the software develop rate.
4

Towards a Predictable Component-Based Run-Time System

Inam, Rafia January 2012 (has links)
In this thesis we propose a technique to preserve the temporal properties of realtime components during their integration and reuse. We propose a new concept of runnable virtual node which is a coarse-grained real-time component that provides functional and temporal isolation with respect to its environment. A virtual node’s interaction with the environment is bounded by both a functional and a temporal interface, and the validity of its internal temporal behaviour is preserved when integrated with other components or when reused in a new environment.   The first major contribution of this thesis is the implementation of a Hierarchical Scheduling Framework (HSF) on an open source real-time operating system (FreeRTOS) with the emphasis of doing minimal changes to the underlying FreeRTOS kernel and keeping its API intact to support the temporal isolation between a numbers of applications, on a single processor. Temporal isolation between the components during runtime prevents failure propagation between different components.   The second contribution of the thesis is with respect to the integration of components, where we first illustrate how the concept of the runnable virtual node can be integrated in several component technologies and, secondly, we perform a proof-of-concept case study for the ProCom component technology where we demonstrate the runnable virtual node’s real-time properties for temporal isolations and reusability.   We have performed experimental evaluations on EVK1100 AVR based 32-bit micro-controller and have checked the system behaviour during heavy-load and over-load situations by visualizing execution traces in both hierarchical scheduling and virtual node contexts. The results for the case study demonstrate temporal error containment within a runnable virtual node as well as reuse of the node in a new environment without altering its temporal behaviour. / PROGRESS
5

Verifying Abstract Components Within Concrete Software Environments

Bao, Tonglaga 26 March 2009 (has links) (PDF)
In order to model check a software component which is not a standalone program, we need a model of the software which completes the program. This problem is important for software engineers who need to deploy an existing component into a new environment. The model is typically generated by abstracting the surrounding software environment in which the component will be executed. However, abstracting the surrounding software is a difficult and error-prone task, particularly when the surrounding software is a complex software artifact which can not be easily abstracted. In this dissertation, we present a new approach to the problem by abstracting the software component under test and leaving the surrounding software concrete. We derive this abstract-concrete mixed model automatically for both sequential and concurrent C programs and verify them using the SPIN model checker. We give verification results for several components under test contained within complex software environments to demonstrate the strengths and weaknesses of our approach. We are able to find errors in components which were too complex for analysis by existing model checking techniques. We prove that this mixed abstract-concrete model can be bisimilar to the original complete software system using an abstraction refinement scheme. We then show how to generate test cases for the component under test using this abstraction refinement process.
6

A component framework for autonomous mobile robots

Orebäck, Anders January 2004 (has links)
The major problem of robotics research today is that there is a barrier to entry into robotics research. Robot system software is complex and a researcher that wishes to concentrate on one particular problem often needs to learn about details, dependencies and intricacies of the complete system. This is because a robot system needs several different modules that need to communicate and execute in parallel. Today there is not much controlled comparisons of algorithms and solutions for a given task, which is the standard scientific method of other sciences. There is also very little sharing between groups and projects, requiring code to be written from scratch over and over again. This thesis proposes a general framework for robotics. By examining successful systems and architectures of past and present, yields a number of key properties. Some of these are ease of use, modularity, portability and efficiency. Even though there is much consensus on that the hybrid deliberate/reactive is the best architectural model that the community has produced so far, a framework should not stipulate a specific architecture. Instead the framework should enable the building of different architectures. Such a scheme implies that the modules are seen as common peers and not divided into clients and servers or forced into a set layering. Using a standardized middleware such as CORBA, efficient communication can be carried out between different platforms and languages. Middleware also provides network transparency which is valuable in distributed systems. Component-based Software Engineering (CBSE) is an approach that could solve many of the aforementioned problems. It enforces modularity which helps to manage complexity. Components can be developed in isolation, since algorithms are encapsulated in components where only the interfaces need to be known by other users. A complete system can be created by assembling components from different sources. Comparisons and sharing can greatly benefit from CBSE. A component-based framework called ORCA has been implemented with the following characteristics. All communication is carried out be either of three communication patterns, query, send and push. Communication is done using CORBA, although most of the CORBA code is hidden for the developer and can in the future be replaced by other mechanisms. Objects are transported between components in the form of the CORBA valuetype. A component model is specified that among other things include support for a state-machine. This also handles initialization and sets up communication. Configuration is achieved by the presence of an XML-file per component. A hardware abstraction scheme is specified that basically route the communication patterns right down to the hardware level. The framework has been verified by the implementation of a number of working systems.
7

The Common Tutor Object Platform

Nuzzo-Jones, Goss F 09 January 2006 (has links)
The Common Tutor Object Platform (CTOP) was designed as a lightweight component framework for creating and deploying applications relating to Intelligent Tutoring Systems. The CTOP supports a runtime for intelligent tutoring system content deployment, a content development environment, an extensive reporting tool, and other smaller applications. The CTOP was designed with future development in mind, allowing easy specification of new base objects and extension points for future development. It has been used as the foundation of the Assistments Project, a wide scale server based ITS deployment. This thesis documents the software engineering aspects of the project. The Assistments Project is capable of supporting a quarter of targeted students in Massachusetts, and optimistically scalable to the entire state and beyond.
8

A component-based approach to modelling software product families with explicit variation points

Di Cola, Simone January 2017 (has links)
In software product line engineering, the construction of an architecture for a product family is still an outstanding engineering challenge. In current practice, a framework is used for configuring individual products by combining solution space artefacts into products with specified features according to a feature model. No architectures are created. In contrast, an architecture for a product family would define the architectures for all the products in the family, allowing engineers to reason at a higher level of abstraction. In this thesis, we present a component model that can be used to define architectures for product families, by incorporating explicit variation points.
9

A Resource-Aware Component Model for Embedded Systems

Vulgarakis, Aneta January 2009 (has links)
<p>Embedded systems are microprocessor-based systems that cover a large range of computer systems from ultra small computer-based devices to large systems monitoring and controlling complex processes. The particular constraints that must be met by embedded systems, such as timeliness, resource-use efficiency, short time-to-market and low cost, coupled with the increasing complexity of embedded system software, demand technologies and processes that will tackle these issues. An attractive approach to manage the software complexity, increase productivity, reduce time to market and decrease development costs, lies in the adoption of the component based software engineering (CBSE) paradigm. The specific characteristics of embedded systems lead to important design issues that need to be addressed by a component model. Consequently, a component model for development of embedded systems needs to systematically address extra-functional system properties. The component model should support predictable system development and as such guarantee absence or presence of certain properties. Formal methods can be a suitable solution to guarantee the correctness and reliability of software systems.</p><p> </p><p>Following the CBSE spirit, in this thesis we introduce the ProCom component model for development of distributed embedded systems. ProCom is structured in two layers, in order to support both a high-level view of loosely coupled subsystems encapsulating complex functionality, and a low-level view of control loops with restricted functionality. These layers differ from each other in terms of execution model, communication style, synchronization etc., but also in kind of analysis which are suitable. To describe the internal behavior of a component, in a structured way, in this thesis we propose REsource Model for Embedded Systems (REMES) that describes both functional and extra-functional behavior of interacting embedded components. We also formalize the resource-wise properties of interest and show how to analyze such behavioral models against them.</p> / PROGRESS
10

Towards Efficient Component-Based Software Development of Distributed Embedded Systems

Sentilles, Séverine January 2009 (has links)
Progress

Page generated in 0.0778 seconds