Application Integration within the Enterprise Context

2009 ◽  
pp. 110-118
Author(s):  
Ronda R. Henning
Keyword(s):  
Life Cycle ◽  
Software Development ◽  
Application Software ◽  
Application Integration ◽  
Software Development Process ◽  
Software Life Cycle ◽  
Enterprise Information ◽  
Requirements Definition ◽  
Representative Problem ◽  
Potential Impact

The application software life cycle considers the functionality of a given collection of components within the context of a consumer’s requirements definition. One set of requirements that are frequently overlooked are the requirements for application integration within the context of the enterprise environment. If an application creates vulnerabilities for other applications, is an administrative nightmare to maintain, or does not consider the security context required for execution; the application may not fulfill the intended requirements. This chapter addresses the question of the consideration of the enterprise information system’s administrative and execution context as a component of the application software development process. The potential impact these considerations have on the acceptance of an application by the application’s user community is presented, with illustrations of some representative problem areas for the reader’s consideration.

scholarly journals The importance of human-computer interaction in the development process of software projects

2015 ◽  
pp. 48 ◽  
Author(s):  
M. Hanefi Calp ◽  
M. Ali Akcayol
Keyword(s):  
Life Cycle ◽  
Software Development ◽  
Human Computer Interaction ◽  
Development Process ◽  
Design Methods ◽  
Software Development Process ◽  
Software Life Cycle ◽  
Software Projects ◽  
User Friendly ◽  
Computer Interaction

<p>Today, software industry has a rapid growth. In order to resist the competition increased by this growth, software projects ne0ed to be developed with higher quality and especially user friendly. Therefore, the importance of human-computer interaction emerges clearly. In design and development phases of software projects, the properties of human –which is an important agent for interaction- such as behavioral, cognitive, perceptive, efficiency and physical factors have to be considered. This study aims to express the importance of developing softwares by taking into consideration the human-computer interaction applications. In this context, firstly a wide literature review is made to examine software development process and human-computer interaction in detail, the results obtained by using design methods in this process are explicated and the importance of said interaction is openly expressed with the exemplary applications in the literature. According to the results of the research, especially in software life cycle, it is observed that rules of interaction must be implemented before software development, however, these methods are usually included in software life cycle in the latter stages of software development process. This situation causes the developed softwares to be user unfriendly and of low quality. Furthermore, it is observed that when the design methods used in the scope of human-computer interaction are integrated into software development process during the life cycle, the developed projects are more successful, have better quality and are more user friendly.</p><p> Keywords: Human-computer interaction, software projects, life cycle, software design.</p>

Towards a Model-Centric Approach for Developing Enterprise Information Systems

2010 ◽  
pp. 140-158
Author(s):  
Petraq Papajorgji ◽  
Panos M. Pardalos
Keyword(s):  
Information Systems ◽  
Software Development ◽  
Programming Languages ◽  
Development Process ◽  
Software Development Process ◽  
Object Constraint Language ◽  
Enterprise Information ◽  
Enterprise Information Systems ◽  
Model Driven ◽  
Modeling Paradigm

This chapter aims to present a new modeling paradigm that promises to significantly increase the efficiency of developing enterprise information systems. Currently, the software industry faces considerable challenges as it tries to build larger, more complex, software systems with fewer resources. Although modern programming languages such as C++ and Java have in general improved the software development process, they have failed to significantly increase developer’s productivity. Thus, developers are considering other paths to address this issue. One of the potential paths is designing, developing and deploying enterprise information systems using the Model Driven Architecture (MDA). MDA is a model-centric approach that allows for modeling the overall business of an enterprise and capturing requirements to developing, deploying, integrating, and managing different kinds of software components without considering any particular implementation technology. At the center of this approach are models; the software development process is driven by constructing models representing the software under development. Code that expresses the implementation of the model in a certain underlying technology is obtained as a result of model transformation. Thus, the intellectual investment spent in developing the business model of an enterprise is not jeopardized by the continuous changes of the implementation technologies. Currently there are two main approaches trying to implement MDA-based tools. One of the approaches is based on the Object Constraint Language and the other on Action Language. An example of designing, developing and deploying an application using this new modeling paradigm is presented. The MDA approach to software development is considered as the biggest shift since the move from Assembler to the first high level languages.

Formal Specifications of Software Model Evolution Using Contracts

2011 ◽  
pp. 184-208
Author(s):  
Claudia Pons ◽  
Gabriel Baum
Keyword(s):  
Software Development ◽  
Development Process ◽  
Formal Specifications ◽  
Software Development Process ◽  
Software Life Cycle ◽  
Software Artifacts ◽  
Software Model ◽  
Intelligent Analysis ◽  
Software Engineers

During the object-oriented software development process, a variety of models of the system is built. All these models are semantically overlapping and together represent the system as a whole. In this chapter, we present a classification of relationships between models along three different dimensions, proposing a formal description of them in terms of mathematical contracts, where the software development process is seen as involving a number of agents (the development team and the software artifacts) carrying out actions with the goal of building a software system that meets the user requirements. In this way, contracts can be used to reason about correctness of the development process, and to compare the capabilities of various groupings of agents in order to accomplish a particular contract. The goal of the proposed formalization is to provide formal foundations for tools that perform intelligent analysis on models assisting software engineers through the software life cycle.

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.

scholarly journals Static analysis of software source code based on the Fortify Static Code Analyzer solution

2021 ◽  
Vol 46 (2) ◽  
Author(s):  
N. V. Goryuk ◽  
◽  
I. M. Lavrovsky
Keyword(s):  
Life Cycle ◽  
Software Development ◽  
Static Analysis ◽  
Source Code ◽  
Security Analysis ◽  
Software Life Cycle ◽  
Static Source

The article analyzes the problem of identifying source code vulnerabilities in the context of software development. An analysis of existing technologies for detecting vulnerabilities in the source code. Methods and means of protection of detection of source code vulnerabilities on the basis of the Fortify Static Code Analyzer solution are investigated. The purpose, main functions and architecture of the Fortify Static Code Analyzer solution are defined. Based on the research conducted in the work, a variant of the process of static analysis of the security of the source code in the context of the software life cycle was developed. Recommendations for the use of static source security analysis technology have been developed.

Quality Assurance in Agile Software Development

2014 ◽  
pp. 155-176 ◽  
Author(s):  
Iwona Dubielewicz ◽  
Bogumila Hnatkowska ◽  
Zbigniew Huzar ◽  
Lech Tuzinkiewicz
Keyword(s):  
Quality Assurance ◽  
Life Cycle ◽  
Best Practices ◽  
Software Development ◽  
Software Quality ◽  
Agile Software Development ◽  
Software Life Cycle ◽  
Agile Methodologies ◽  
Agile Practices ◽  
Agile Software

Agile methodologies have become very popular. They are defined in terms of best practices, which aim at developing good quality software faster and cheaper. Unfortunately, agile methodologies do not refer explicitly to quality assurance, which is understood as a planned set of activities performed to provide adequate confidence that a product conforms to established requirements, and which is performed to evaluate the process by which products are developed. The chapter considers the relations of agile practices with software life cycle processes, especially those connected to quality assurance, and tries to answer the question of which agile practices ensure software quality. Next, agile practices associated with quality assurance are assessed from different perspectives and some recommendations for their usage are given. It is observed that modeling has a particular impact on quality assurance.

Requirements to Products and Processes for Software of Safety Important NPP I&C Systems

2022 ◽  
pp. 212-246
Author(s):  
Vladimir Sklyar ◽  
Andriy Volkoviy ◽  
Oleksandr Gordieiev ◽  
Vyacheslav Duzhyi
Keyword(s):  
Life Cycle ◽  
Software Development ◽  
Software Verification ◽  
Software Requirements ◽  
Software Components ◽  
Software Life Cycle ◽  
Regulatory Documents ◽  
And Control

Features of software as a component of instrumentation and control (I&C) systems are analyzed. Attention is paid to the importance of functions performed by software and hazards of such software. Requirements for characteristics of software as a component of I&C systems are analyzed. Different regulatory documents are considered in order to disclose common approaches to the use of dedicated software and off-the-shelf software components. Classification of software, as well as classification of requirements, is described. Criteria of selection and structuring of requirements, as well as criteria for software verification, are defined. As long as the characteristics of software components directly depend on the quality of the processes of software development and verification, requirements for software life cycle processes are considered.

The Design of Software Parallel Engineering Model Based on Petri Net

2011 ◽  
Vol 186 ◽  
pp. 317-321
Author(s):  
Yu Qiang Sun ◽  
Shi Yan Xie ◽  
Yu Wan Gu ◽  
Hai Feng Shi
Keyword(s):  
Particle Size ◽  
Life Cycle ◽  
Software Development ◽  
Petri Net ◽  
Software Process ◽  
Engineering Model ◽  
Software Life Cycle ◽  
Software Model ◽  
Software Productivity ◽  
Development Cycle

In the paper, Using Petri net to a component-based reuse-driven software model for parallel engineering is proposed. The model applies Petri net to analyze parallelism in the entire software process. The model excavates fully Parallelism during software life cycle, supports various parallel of different particle size coarse and fine. The model can greatly enhance the software development, software productivity and shorten the development cycle.

Sign in / Sign up

Export Citation Format

Share Document