DPSSEE

2011 ◽  
pp. 409-438 ◽  
Author(s):  
Donghua Deng ◽  
Phillip C.Y. Sheu
Keyword(s):  
Life Cycle ◽  
Software Engineering ◽  
Software Development ◽  
Control Design ◽  
Consistency Checking ◽  
Software Life Cycle ◽  
Description Language ◽  
Model Based Testing ◽  
Engineering Environment ◽  
Design Consistency

This chapter presents a distributed proactive semantic software engineering environment (DPSSEE) that incorporates logic rules into a software development process to capture the semantics from all levels of the software life cycle. It introduces the syntax and semantics of the Semantic Description Language (SDL). It also introduces model-based testing and maintenance. Several working scenarios are discussed to illustrate the use of semantic rules for workflow control, design consistency checking, testing, and maintenance.

Investigating the Effect of Software Complexity Metrics on Software Cost

2014 ◽  
Vol 548-549 ◽  
pp. 1319-1325
Author(s):  
Bouchaib Falah ◽  
Sara El Alaoui ◽  
Hajar Abbadi
Keyword(s):  
Life Cycle ◽  
Software Engineering ◽  
Software Metrics ◽  
Software Life Cycle ◽  
Software Cost ◽  
Software Complexity ◽  
Complexity Metrics ◽  
Extended Lifespan ◽  
New Methodologies ◽  
Do So

Nowadays, software is expected to have an extended lifespan, which makes the evaluation of its complexity at the early stages critical in upcoming maintenance. Indeed, complexity is proportional to the evolution of software. Software metrics were introduced as tools that allow us to obtain an objective measurement of the complexity of software. Hence, enabling software engineering to assess and manage software complexity. Reducing software costs is one of the major concerns of software engineering which creates an increasing need for new methodologies and techniques to control those costs. Software complexity metrics can help us to do so. In this paper, we would investigate how those metrics can be used to reduce software costs. We would first analyze the most popular complexity metrics and distinguish their properties. Then, we will show how each of those metrics fit within the software life cycle. Finally, we will provide a detailed approach to use the complexity metrics to reduce software costs.

TRENDS IN LIFE-CYCLE MODELS FOR SE AND KE: PROPOSAL FOR A SPIRAL-CONICAL LIFE-CYCLE APPROACH

1995 ◽  
Vol 05 (03) ◽  
pp. 445-465 ◽  
Author(s):  
F. ALONSO ◽  
N. JURISTO ◽  
J. PAZOS
Keyword(s):  
Life Cycle ◽  
Software Engineering ◽  
Software Development ◽  
21St Century ◽  
Knowledge Engineering ◽  
Life Cycle Approach ◽  
Life Cycle Model ◽  
Cycle Model ◽  
Knowledge Based ◽  
Technological Tools

The ten-year gap between the emergence of Software Engineering (SE) and Knowledge Engineering (KE) has led to the two disciplines developing along different methodological lines. In this paper, we point out that, after having passed through a period during which they ignored each other, followed by a competitive phase, the two disciplines have now reached a meeting point. We see the need for a life-cycle model for systems that integrate traditional and knowledge-based software. Besides, software development in the 21st century will entail open requirements and technological tools that will evolve during the life-cycle. Finally, the paper discusses a proposal for a conical-type spiral life-cycle model that seeks to meet all those needs.

A Simulation Based Approach for Software Release and Support Management

2008 ◽  
Vol 4 (4) ◽  
pp. 124-128
Author(s):  
Vikram Singh
Keyword(s):  
Life Cycle ◽  
Software Development ◽  
Life Cycle Cost ◽  
Project Managers ◽  
Software Project ◽  
Market Place ◽  
Software Life Cycle ◽  
Simulation Based ◽  
Software Product ◽  
Software Release

Deciding when to stop testing and deliver or release a software product in the competitive market place, is an important decision in software project management. Software tools are available in the market for backing the decisions of project managers with regards to software release. Also, software development houses may need to know “for how long should they support and maintain their software product after release?” A few tools are available that take into account the software product support activities that go beyond software release while computing and optimizing software life cycle cost. A simulation based approach has been devised for helping Software Project Managers in deciding: 1) How long to test software? 2) How long to provide free support to the product? 3) When to withdraw the product support?

scholarly journals Analyzing Static Analysis Metric Trends towards Early Identification of Non-Maintainable Software Components

2021 ◽  
Vol 13 (22) ◽  
pp. 12848
Author(s):  
Thomas Karanikiotis ◽  
Michail D. Papamichail ◽  
Andreas L. Symeonidis
Keyword(s):  
Life Cycle ◽  
Software Development ◽  
Static Analysis ◽  
Continuous Process ◽  
Primary Source ◽  
Evaluation Methodology ◽  
Software Life Cycle ◽  
Class Level ◽  
Agile Software ◽  
Fast Release

Nowadays, agile software development is considered a mainstream approach for software with fast release cycles and frequent changes in requirements. Most of the time, high velocity in software development implies poor software quality, especially when it comes to maintainability. In this work, we argue that ensuring the maintainability of a software component is not the result of a one-time only (or few-times only) set of fixes that eliminate technical debt, but the result of a continuous process across the software’s life cycle. We propose a maintainability evaluation methodology, where data residing in code hosting platforms are being used in order to identify non-maintainable software classes. Upon detecting classes that have been dropped from their project, we examine the progressing behavior of their static analysis metrics and evaluate maintainability upon the four primary source code properties: complexity, cohesion, inheritance and coupling. The evaluation of our methodology upon various axes, both qualitative and quantitative, indicates that our approach can provide actionable and interpretable maintainability evaluation at class level and identify non-maintainable components around 50% ahead of the software life cycle. Based on these results, we argue that the progressing behavior of static analysis metrics at a class level can provide valuable information about the maintainability degree of the component in time.

Sign in / Sign up

Export Citation Format

Share Document