Good documentationis important for the production of reusable and maintainable software. Ft)rthe production ofaccurate documentation itisnecessary that the original program text is not copied manually to obtain a typeset version. Apart from being tedious, this will invariably introduce errors. The production of tools that support the production of legible and accurate documentation is a software engineering challenge in itself. We present an algebraic approach to tht, generation of tools that produce typographically effective presentations of computer programs, A specification of a formatter is generated from the context-free grammar of a (progmmrningl language. These generated formatters translate abstract syntax trees of programs into box expressions.Box expressions are translated by language-independent interpreters of the box language into ASCII or TEX. The formatting rules that are generated can easily be tuned in order to get the desired formatting of programs. We demonstrate this by means of real-life applications, Furthermore, we give a practical solution for the problem of formatting comments, which occur in the original text, The formatter generation approach proposed in this article can be used to generate formatting programs for arbitrary programming environments. our forrnatte rgeneration approach can be used to automatically generate formatters that have t<)be programmed explicitly in other systems.
Today, when constructing software systems, many developers build their systems on top of frameworks. Eclipse is such a framework that has been in existence for over a decade. Like many other evolving software systems, the Eclipse platform has both stable and supported interfaces (''good'') and unstable, discouraged and unsupported interfaces (''bad''). In this study, we investigate Eclipse interface usage by Eclipse thirdparty plug-ins (ETPs) based on whether they use bad interfaces or not. The investigations, based on empirical analysis present the following observations. First, we discovered that 44 % of the 512 analyzed Eclipse third-party plug-ins depend on ''bad'' interfaces and that developers continue to use ''bad'' interfaces. Second, we have observed that plug-ins that use or extend at least one ''bad'' interface are comparatively larger and use more functionality from Eclipse than those that use only ''good'' interfaces. Third, the findings show that the ETPs use a diverse set of ''bad'' interfaces. Fourth, we observed that the reason why the bad interfaces are being eliminated from the ETPs' source code is, because (ETP developers believe) these non-APIs will cause incompatibilities when a version of the ETP is ported to new Eclipse SDK release. Finally, we observed that when developers eliminate problematic ''bad'' interfaces, they either re-implement the same functionality in their own API, find equivalent SDK good interfaces, or completely delete the entities in the ETPs' source code that use the functionality from the ''bad'' interfaces.
Abstract-Today numerous software systems are being developed on top of frameworks. In this study, we analyzed the survival of 467 Eclipse third-party plug-ins altogether having 1,447 versions. We classify these plug-ins into two categories: those that depend on only stable and supported Eclipse APIs and those that depend on at least one of the potentially unstable, discouraged and unsupported Eclipse non-APIs.Comparing the two categories of plug-ins, we observed that the plug-ins depending solely on APIs have a very high source compatibility success rate compared to those that depend on at least one of the non-APIs. However, we have also observed that recently released plug-ins that depend on non-APIs also have a very high forward source compatibility success rate. This high source compatibility success rate is due to the dependency structure of these plug-ins: recently released plug-ins that depend on non-APIs predominantly depend on old Eclipse nonAPIs rather than on newly introduced ones. Finally, we showed that the majority of plug-ins hosted on SourceForge do not evolve beyond the first year of release.
No abstract
scite is a Brooklyn-based organization that helps researchers better discover and understand research articles through Smart Citations–citations that display the context of the citation and describe whether the article provides supporting or contrasting evidence. scite is used by students and researchers from around the world and is funded in part by the National Science Foundation and the National Institute on Drug Abuse of the National Institutes of Health.
hi@scite.ai
10624 S. Eastern Ave., Ste. A-614
Henderson, NV 89052, USA
Copyright © 2024 scite LLC. All rights reserved.
Made with 💙 for researchers
Part of the Research Solutions Family.