Name
Abstract | ||
|---|---|---|
Prior research has shown that high levels of software reuse can be achieved through the use of object- oriented frameworks. An object-orient ed framework captures the common aspects of a family of applications, and thus, allows the designers and implementers to reuse this experience at the design and code levels. Despite of being a powerful design solution, frameworks are not always easy to use. This paper describes a technique that uses domain specific languages (DSL) to describe the framework variation points and therefore syntactically assure the creation of valid framework instances. This approach allows framework users to develop applications without worrying about the framework implementation and remaining focused on the problem domain. In addition, the use of DSLs allow for better error handling, when compared to the standard approach of adapting frameworks by directly adding subclasses. The DSL programs are translated to the framework instantiation code using a transformational system. The approach is illustrated through two real-world frameworks. Object-oriented frameworks and product line architectures have become popular in the software industry during the 1990s. Numerous frameworks have been developed in industry and academia for various domains, including graphical user interfaces (e.g. Java's Swing and other Java standard libraries, Microsoft's MFC), graph-based editors (HotDraw, Stingray's Objective Views), business applications (IBM's San Francisco), network servers (Java's Jeeves), just to mention a few. When combined with components, frameworks provide the most promising current technology supporting large-scale reuse (17). A framework is a collection of several fully or partially implemented components with largely predefined cooperation patterns between them. A framework implements a software architecture for a family of applications with similar characteristics (26), which are derived by specializatio n through application- specific code. Hence, some of the framework components are designed to be replaceable. We call these components the variation points or hot-spots (27) of the framework. Moreover, an application based on such a framework not only reuses the frameworks source code, but also its architecture design. This amounts to a standardization of the application structure and allows a significant reduction of the size and complexity of the source code that has to be written by developers who instantiate a framework (11). The bad news is that framework usability can be a problem. The most common way to instantiate a framework is to inherit from abstract classes defined in the framework hierarchy and to write the required instantiation code. However, it is not always easy to identify which code is needed to instantiate a framework and where it should be written since class hierarchies can be very complex. Application developers have to rely on extra documentation to be able to create framework instances properly, since it is very unlikely that they will be able to browse the framework classes and write the required instantiation code if no adequate documentation is provided. |
Year | DOI | Venue |
|---|---|---|
2000 | 10.1049/ip-sen:20000791 | IEE Proceedings - Software |
Keywords | Field | DocType |
object-oriented methods,software reusability,specification languages,domain specific languages,error handling,framework variation points,object-oriented frameworks,software reuse | Domain-specific language,Programming language,Object-oriented programming,Problem domain,Computer science,Digital subscriber line,Reuse,Transformational leadership,Software,Spite | Journal |
Volume | Issue | ISSN |
147 | 4 | 1462-5970 |
Citations | PageRank | References |
5 | 0.52 | 17 |
Authors | ||
4 | ||
Name | Order | Citations | PageRank |
|---|---|---|---|
| Marcus Fontoura | 1 | 1116 | 61.74 |
| Christiano Braga | 2 | 180 | 17.38 |
| Leonardo Moura | 3 | 5 | 0.52 |
| C. J. Lucena | 4 | 6 | 1.26 |