NDLI: The FUJABA environment

Please wait, while we are loading the content...

Is the new economy socially sustainable? (invited presentation) (abstract only)

The future of software (invited presentation) (abstract only)

Dot com versus bricks and mortar — the impact of portal technology (invited presentation) (abstract only)

Requirements engineering in the year 00: a research perspective

A case study: demands on component-based development

Investigating and improving a COTS-based software development

PPT: a COTS integration case study

Supporting diversity with component frameworks as architectural elements

Requirements engineering for product families

Extending requirement specifications using analogy

It's engineering Jim … but not as we know it: software engineering — solution to the software crisis, or part of the problem?

Producing more reliable software: mature software engineering process vs. state-of-the-art technology?

Improving problem-oriented mailing list archives with MCS

Broad-spectrum studies of log file analysis

Multivariate visualization in observation-based testing

An empirical study of regression test application frequency

Testing levels for object-oriented software

Software evolution in componentware using requirements/assurances contracts

An integrated cost model for software reuse

Data mining library reuse patterns using generalized association rules

Towards a taxonomy of software connectors

A formal approach for designing CORBA based applications

Simulation in software engineering training

Twenty dirty tricks to train software engineers

Deriving test plans from architectural descriptions

WYSIWYT testing in the spreadsheet paradigm: an empirical evaluation

Integrating UML diagrams for production control systems

Dragonfly: linking conceptual and implementation architectures of multiuser interactive systems

A case study of open source software development: the Apache server

Multiple mass-market applications as components

Developing and deploying software engineering courseware in an adaptable curriculum framework

Achieving industrial relevance with academic excellence: lessons from the Oregon Master of Software engineering

Inference of message sequence charts

Generating statechart designs from scenarios

Object model resurrection — an object oriented maintenance activity

Action Language: a specification language for model checking reactive systems

Three approximation techniques for ASTRAL symbolic model checking of infinite state real-time systems

Component design of retargetable program analysis tools that reuse intermediate representations

Light-weight context recovery for efficient and accurate program analyses

A replicated assessment and comparison of common software cost modeling techniques

Characterization of risky projects based on project managers' evaluation

Implementing incremental code migration with XML

Principled design of the modern Web architecture

A study on exception detection and handling using aspect-oriented programming

A case study in root cause defect analysis

Bandera: extracting finite-state models from Java source code

Quickly detecting relevant program invariants

Characterizing implicit information during peer review meetings

Object-oriented inspection in the face of delocalisation

An inheritance-based technique for building simulation proofs incrementally

Verification of time partitioning in the DEOS scheduler kernel

Graphical animation of behavior models

Towards the principled design of software engineering diagrams

From MCC and CMM: technology transfers bright and dim

Fraunhofer: the German model for applied research and technology transfer

Software development engineer in Microsoft: a subjective view of soft skills required

Software needs engineering: a position paper

Is software education narrow-minded?: a position paper

An approach to architectural analysis of product lines

Introducng a software modeling concept in a medium-sized company

From research to reward: challenges in technology transfer

Technology transfer macro-process: a practical guide for the effective introduction of technology

When the project absolutely must get done: marrying the organization chart with the precedence diagram

An evaluation of the paired comparisons method for software sizing

Grow fast, grow global: how the Irish software industry evolved to this business model

The making of Orbix and the iPortal suite

Improvement of a configuration management system

Applying and adjusting a software process improvement model in practice: the use of the IDEAL model in a small software enterprise

European experiences with software process improvement

Software process improvement by object technology (ESSI PIE 27785 — SPOT)

Daily build and feature development in large distributed projects

Why don't we get more (self?) respect: the positive impact of software engineering research upon practice

Component-based software engineering and the issue of trust

Shortages of qualified software engineering faculty and practitioners (panel session): challenges in breaking the cycle

Who needs doctors? (panel session) (abstract only)

Lessons learned from teaching reflective software engineering using the Leap toolkit

Can quality graduate software engineering courses really be delivered asynchronously on-line?

Multibook's test environment

E-Slate: a software architectural style for end-user programming

An interactive multimedia software house simulation for postgraduate software engineers

LIGHTVIEWS — visual interactive Internet environment for learning OO software testing

The ICSE2000 doctoral workshop

A logical framework for design composition

Algorithmic cost estimation for software evolution

Estimating software fault-proneness for tuning testing activities

Formal verification applied to Java concurrent software

Supporting dynamic distributed work processes with a component and event based approach

Platform-independent and tool-neutral test descriptions for automated software testing

Contribution to simplifying the mobile agent programming

Spontaneous software: a Web-based, object computing paradigm

Automated refactoring to introduce design patterns

High-integrity code generation for state-based formalisms

Alcoa: the alloy constraint analyzer

Hyper/J: multi-dimensional separation of concerns for Java

A software engineering approach and tool set for developing Internet applications

The FUJABA environment

Managing software artifacts on the Web with Labyrinth

Galileo: a tool built from mass-market applications

Little-JIL/Juliette: a process definition language and interpreter

Analyzing software architectures with Argus-I

Bandera: a source-level interface for model checking Java programs

Developing mobile computing applications with LIME

Component composition (poster session)

Third eye — specification-based analysis of software execution traces (poster session)

Empirical investigation of a novel approach to check the integrity of software engineering measuring processes (poster session)

The implication of different learning styles on the modeling of object-oriented systems (poster session)

A culture-centered multilevel software process cycle model (poster session)

Using application states in software testing (poster session)

Effort estimation from change records of evolving software (poster session)

Modeling deployment and configuration of CORBA systems with UML (poster session)

As strong as possible mobility (poster session)

Hybrid domain representation archive (HyDRA) for requirements model synthesis across viewpoints (poster session)

The use of task analysis methods in support of the development of interactive systems

DeBOT — an approach for constructing high performance, scalable distributed object systems (panel session)

Exploring O-O framework usage (poster session)

Tracking, predicting and assessing software reuse costs: an automated tool

Holmes: a system to support software product lines

Supporting dynamic composition of components

Prompter — a project planning assistant

Visualizing software release histories with 3DSoftVis

Legacy systems migration in CelLEST

Process engineering with Spearmint/EPG

An overview of the ICSE 2000 workshop program

Second ICSE Workshop on Web Engineering (workshop session)

The First International Workshop on Automated Program Analysis, Testing and Verification (workshop session)

COTS Workshop: continuing collaborations for successful COTS development

Beg, borrow, or steal (workshop session): using multidisciplinary approaches in empirical software engineering research

The Second International Symposium on Constructing Software Engineering Tools (CoSET2000) (workshop session)

Design, specification, and verification of interactive systems (workshop session)

Workshop on standard exchange format (WoSEF) (workshop session)

3rd workshop on software engineering over the Internet (workshop session)

Workshop on multi-dimensional separation of concerns in software engineering (workshop session)

The 2nd International Workshop on Economics-Driven Software Engineering Research (workshop session)

WISE3: the Third International Workshop on Intelligent Software Engineering (workshop session)

Software product lines (workshop session): economics, architectures, and applications

Agent-oriented software engineering (workshop session)

Specifying and measuring quality in use (tutorial session)

Designing and analyzing software architectures using ABASs (tutorial session)

Building modular object-oriented systems with reusable collaborations (tutorial session)

Introduction to CORBA (tutorial session)

Moving from ISO9000 to higher levels of the CMM (tutorial session)

Planning realistic schedules using software architecture (tutorial session)

Improving design and source code modularity using AspectJ (tutorial session)

Scalability issues in CORBA-based systems (tutorial session)

Intellectual property protection for software in the United States and Europe (tutorial session): the changing roles of patents and copyrights

Software process improvement (tutorial session): best practices and lessons learned

Designing real-time and distributed applications with the UML (tutorial session)4

System development using application services over the Net (tutorial session)

Software reliability (tutorial session): basic concepts and assessment methods

Product-line architectures, aspects, and reuse (tutorial session)

Advanced visual modeling (tutorial session): beyond UML

Understanding code mobility (tutorial session)

Fault tolerance via diversity against design faults (tutorial session): design principles and reliability assessment

Improving software inspections by using reading techniques (tutorial session)

The FUJABA environment

Content Provider	ACM Digital Library
Author	Niere, Jörg Nickel, Ulrich Zündorf, Albert
Abstract	However, a single collaboration diagram is usually not expressive enough to model complex operations performing several modifications at different parts of the overall object structure. Such series of modifications need several collaboration diagrams to be modeled. In addition, there may be different situations where certain collaboration diagrams should be executed and others not. Thus, we need additional control structures to control the execution of collaboration diagrams. In our approach we combine collaboration diagrams with statecharts and activity diagrams for this purpose. This means, instead of just pseudo code, any state or activity may contain a collaboration diagram modeling the do-action of this step.Figure 1 illustrates the main concepts of Fujaba. Fujaba uses a combination of statecharts and collaboration diagrams to model the behavior of active classes. A combination of activity diagrams and collaboration diagrams models the bodies of complex methods. This integration of class diagrams and UML behavior diagrams enables Fujaba to perform a lot of static analysis work facilitating the creation of a consistent overall specification. In addition, it turns these UML diagrams into a powerful visual programming language and allows to cover the generation of complete application code. During testing and maintenance the code of an application may be changed on the fly, e.g. to fix small problems. Some application parts like the graphical user interface or complex mathematical computations may be developed with other tools. In cooperative (distributed) software development projects some developers may want to use Fujaba, others may not. Code of different developers may be merged by a version management tool. There might already exist a large application and one wants to use Fujaba only for new parts. One may want to do a global search-and-replace to change some text phrases. One may temporarily violate syntactic code structures while she or he restructures some code. For all these reasons, Fujaba aims to provide not just code generation but also the recovery of UML diagrams from Java code. One may analyse (parts of) the application code, recover the corresponding UML diagram (parts), modify these diagram (parts), and generate new code (into the remaining application code). So far, this works reasonable for class diagrams and to some extend for the combination of activity and collaboration diagrams. For statecharts this is under development.The next chapters outline the (forward engineering) capabilities of Fujaba with the help of an example session.
Starting Page	742
Ending Page	745
Page Count	4
File Format	PDF
ISBN	1581132069
DOI	10.1145/337180.337620
Language	English
Publisher	Association for Computing Machinery (ACM)
Publisher Date	2000-06-01
Publisher Place	New York
Access Restriction	Subscribed
Content Type	Text
Resource Type	Article

Central Library (ISO-9001:2015 Certified)
Indian Institute of Technology Kharagpur
Kharagpur, West Bengal, India | PIN - 721302

See location in the Map
03222 282435
Mail: support@ndl.gov.in

Sl.	Authority	Responsibilities	Communication Details
1	Ministry of Education (GoI), Department of Higher Education	Sanctioning Authority	https://www.education.gov.in/ict-initiatives
2	Indian Institute of Technology Kharagpur	Host Institute of the Project: The host institute of the project is responsible for providing infrastructure support and hosting the project	https://www.iitkgp.ac.in
3	National Digital Library of India Office, Indian Institute of Technology Kharagpur	The administrative and infrastructural headquarters of the project	Dr. B. Sutradhar bsutra@ndl.gov.in
4	Project PI / Joint PI	Principal Investigator and Joint Principal Investigators of the project	Dr. B. Sutradhar bsutra@ndl.gov.in Prof. Saswat Chakrabarti will be added soon
5	Website/Portal (Helpdesk)	Queries regarding NDLI and its services	support@ndl.gov.in
6	Contents and Copyright Issues	Queries related to content curation and copyright issues	content@ndl.gov.in
7	National Digital Library of India Club (NDLI Club)	Queries related to NDLI Club formation, support, user awareness program, seminar/symposium, collaboration, social media, promotion, and outreach	clubsupport@ndl.gov.in
8	Digital Preservation Centre (DPC)	Assistance with digitizing and archiving copyright-free printed books	dpc@ndl.gov.in
9	IDR Setup or Support	Queries related to establishment and support of Institutional Digital Repository (IDR) and IDR workshops	idr@ndl.gov.in