Event-driven programming often takes advantage of effects to implement interactive features. Understanding the role of objects from the viewpoint of effects is important to understand the implementation of interactive...
详细信息
ISBN:
(纸本)1891706241
Event-driven programming often takes advantage of effects to implement interactive features. Understanding the role of objects from the viewpoint of effects is important to understand the implementation of interactive features. However, currently no existing methods support comprehension of object's roles in taking advantage of effects. In this paper, we propose a modeling framework that becomes the basis of a trace analysis method to comprehend the roles of objects in taking advantage of effects in a feature implementation. The proposed framework provides maintainers a low-level trace model to represent runtime effects 'as is', and a high-level model to abstract the effects according to maintainers' concerns. The framework also defines analysis commands to construct such abstraction of runtime effects. Using the analysis commands, we describe a practical analysis scenario to detect a method execution that triggers the calculation of an output of a feature using previous user inputs.
In software tools for modeling and simulation of complex systems described through ODEs (e.g. those occurring in the scope of water quality research), hierarchical composition is often adopted as a mechanism to handle...
详细信息
ISBN:
(纸本)9780975840078
In software tools for modeling and simulation of complex systems described through ODEs (e.g. those occurring in the scope of water quality research), hierarchical composition is often adopted as a mechanism to handle complexity. Currently, two competing techniques are used with regard to the generation of executable code from hierarchical models: component-based modeling and flattening. In component-based modeling, hierarchical models are constructed on the basis of self-contained binary components representing atomic sub-models. The manner in which these binary components are implemented is usually of no importance, as long as each component implements a specific well-defined inter-component interfacing protocol. A prime example of a tool that supports component-based modeling is MATLAB's Simulink toolbox. The more recent flattening paradigm is typically adopted in the scope of high-level - often object-oriented -modeling languages such as Modelica and MSL. Non-executable, high-level model descriptions are processed by a model compiler in order to produce efficient, low-level, binary executable model code. During this process, the original composition and inheritance hierarchies are resolved in order to produce one large flat set of equations that offers potential for code optimization (i.e. automatic reduction of complexity). Examples of tools that adopt flattening are Dynasim's Dymola, the OSMC's OpenModelica and MOSTforWATER's Tornado. Flattening is often advocated as an approach that is superior to component-based modeling and hence alleviates the need for the latter. However, in practice both approaches have their own distinct merits. Flattening allows for constructing highly efficient monolithic executable models, however the model compilation process tends to be prohibitively time-consuming for large models, and may even lead to depletion of memory in extreme cases. Component-based modeling on the other hand leads to less efficient executable models (due to
Environmental modeling frameworks provide an array of useful features that model developers can harness when implementing models. Each framework differs in how it provides features to a model developer via its Applica...
详细信息
ISBN:
(纸本)9780975840078
Environmental modeling frameworks provide an array of useful features that model developers can harness when implementing models. Each framework differs in how it provides features to a model developer via its Application programming Interface (API). Environmental modelers harness framework features by calling and interfacing with the framework API. As modelers write model code, they make framework-specific function calls and use framework specific data types for achieving the functionality of the model. As a result of this development approach, model code becomes coupled with and dependent on a specific modeling framework. Coupling to a specific framework makes migration to other frameworks and reuse of the code outside the original framework more difficult. This complicates collaboration between model developers wishing to share model code that may have been developed in a variety of languages and frameworks. This paper provides initial results of an exploratory investigation on the invasiveness of environmental modeling frameworks. Invasiveness is defined as the coupling between application (i.e., model) and framework code used to implement the model. By comparing the implementation of an environmental model across several modeling frameworks, we aim to better understand the consequences of framework design. How frameworks present functionality to modelers through APIs can lead to consequences with respect to model development, model maintenance, reuse of model code, and ultimately collaboration among model developers. By measuring framework invasiveness, we hope to provide environmental modeling framework developers and environmental modelers with valuable information to assist in future development efforts. Eight implementations (six framework-based) of Thornthwaite, a simple water balance model, were made in a variety of environmental modeling frameworks and languages. A set of software metrics were proposed and applied to measure invasiveness between model im
An objectoriented approach has been developed using Lab VIEW RT. This real-time variant of the well known graphical programming language is based on the PharLap OS. This approach allows for two different scenarios. F...
详细信息
In this paper we introduce a new view on roles in object oriented programming languages. Our notion is based on an ontological analysis of social roles and attributes to roles the following properties: first, a role i...
详细信息
This workshop provides a visual manner in which to introduce OOP using Java. The Gogga class is a simple graphical tool which provides a Gogga object that can, in essence, move (), turnLeft () and turnRight (). Using ...
详细信息
ISBN:
(纸本)1920017119
This workshop provides a visual manner in which to introduce OOP using Java. The Gogga class is a simple graphical tool which provides a Gogga object that can, in essence, move (), turnLeft () and turnRight (). Using these methods, simple rectangular shapes can be drawn on an output grid. The Gogga class also includes other methods to change the colour and the thickness of the lines drawn as well as setting and returning the position of any Gogga object. Since the Gogga class only provides basic movements for objects instantiated from it, objects of classes that inherit from the Gogga class will have the basic movements as well as more functionality provided by the new inheriting classes. Length required: 90 minutes Requirements: Delegates need to have a fundamental knowledge of programming in any high-level language, including a fair understanding of the use of loops and subprograms. Structure of the workshop: 1. Introduction to a simple Java program that uses an object of the Gogga class to draw a square. Exercise to draw a rectangle in Java with a Gogga object. The exercise is extended to include colour and lines of different thicknesses. The exercise is further extended to include for loops and methods. 2. A new class RectGogga is created that inherits from the Gogga class. objects of this class are used to draw rectangles of different sizes. Brief explanation of syntax used with inheritance. Exercise to create a new class Pyramid to create objects that draw pyramid shapes of any size. This class is called from a program that will draw pyramids of any sizes. Exercise to draw a house using the new methods in the Pyramid and RectGogga classes.
Today's test environment is more challenging than ever as pressure on increasing quality and meeting time-to-market continue to increase. Because of these recent advances in computer and other technologies, it is ...
详细信息
ISBN:
(纸本)9781932415704
Today's test environment is more challenging than ever as pressure on increasing quality and meeting time-to-market continue to increase. Because of these recent advances in computer and other technologies, it is becoming evident that a sound foundation in computer networking is critical for success in many kinds of computer-based work and universities must produce graduates with solid foundation in computers and their applications to solve real world problems. One way to achieve this is through interactive learning and teaching through the use of software packages like Lab VIEW (Virtual Instruments) and Java/Visual Basic (object oriented programming). This will also allow the student to have greater interaction with the subject matter and improve his/her skills in the use of number of applied engineering software packages. This paper will discuss design and development of interactive instructional modules for Number Systems, Internet Protocol Addresses, Address Classes, Subnet Masks, and Subnetting using LabVIEWand Visual Basic/Java.
Component-based development (CBD) has become an important emerging topic in the software engineering field. It promises long-sought-after benefits such as increased software reuse, reduced development time to market a...
详细信息
Component-based development (CBD) has become an important emerging topic in the software engineering field. It promises long-sought-after benefits such as increased software reuse, reduced development time to market and, hence, reduced software production cost. Despite the huge potential, the lack of reasoning support and development environment of component modeling and verification may hinder its development. Methods and tools that can support component model analysis are highly appreciated by industry. Such a tool support should be fully automated as well as efficient. At the same time, the reasoning tool should scale LIP well as it may need to handle hundreds or even thousands of components that a modern software system may have. Furthermore, a distributed environment that can effectively manage and compose components is also desirable. In this paper, we present an approach to the modeling and verification of a newly proposed component model using Semantic Web languages and their reasoning tools. We use the Web Ontology Language and the Semantic Web Rule Language to precisely capture the inter-relationships and constraints among the entities in a component model. Semantic Web reasoning tools are deployed to perform automated analysis support of the component models. Moreover, we also proposed a service-oriented architecture (SOA)-based semantic web environment for CBD. The adoption of Semantic Web services and SOA make our component environment more reusable, scalable, dynamic and adaptive.
This work proposes the implementation of a Supervisory, Control and Data Acquisition (SCADA) System for a Flexible Manufacturing System (FMS) based on an object-oriented Petri Net model of the plant. Considering the c...
详细信息
This work proposes the implementation of a Supervisory, Control and Data Acquisition (SCADA) System for a Flexible Manufacturing System (FMS) based on an object-oriented Petri Net model of the plant. Considering the complexity of a FMS (different types of parts and raw materials, different schedules, processes and programs to deal with, ways of handling parts, etc.), the implementation of a SCADA System to manage and control the plant is complex and susceptible to errors, even deadlocks. The creation of a program based on a formal model capable of dealing with such complexity and problems minimizes mistakes and allows such a model to be simulated, anticipating error situations and its possible solutions. The editing and debugging processes are also facilitated, as well as the inclusion of new types of parts or processes that can be easily performed by the definition of new attributes and methods according to the model. The analysis of the program performance is carried out using a formal methodology based on the model. A case-study implementation is shown for demonstration and validation purposes.
This paper proposes a "scoped permission" system for a simple object-oriented language with shared-memory and structural parallelism. The permission is abstracted as a linear value associated with some piece...
详细信息
暂无评论