ffpEmerging Trends of Software Engineering And Verification

DOI : 10.17577/IJERTCONV2IS02017

Download Full-Text PDF Cite this Publication

Text Only Version

ffpEmerging Trends of Software Engineering And Verification

Prof. Shivraj .P.Patil CSE Prof. Gangadhar.G.H CSE Asst.Prof.Sneha.Mankare CSE

Basavakalyan Engineering College

sppatil16@gmail.com gangadhara_h@yahoo.com mankare.sneha@gmail.com


Software is an important aspect of modern society. It is seen in every day to day human usable technology from buying bread, driving car, washing clothes to managing finances, communication regulation and generation of power and processing of information in secured manner. Software engineering is the application of a systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software; that is, the application of engineering to software. The people who develop them are software engineers, s/w developers and s/w programmers. S/W separated from hardware in early 1950s and emerged as distinct and independent technology. Following are s/w development practices but it may vary depending on the process:

Requirements engineering System analysis

High-level design/architecture Low-level design

Coding Integration

Design and code reviews Testing

Maintenance Project management

Configuration management

Index TermsDeductive verification, scalable spiral model, automatic programming, agile and plan driven methods, Software verification

  1. Introduction

    A software development process is the process by which user needs are translated into a software product. The process involves translating user needs

    Into software requirements, transforming the software requirements into design, implementing the design in code, testing the code, and sometimes installing and checking out the software for operational use. A software process model is a simplified, abstracted description of a software development process. The primary purpose of a software process model is to determine the order of stages involved in software development and to establish the transition criteria for

    progressing from one stage to the next (Boehm, May 1988).

    Process models have begun to be characterized as plan- driven or agile. The plan-driven models have an implicit assumption that a good deal of information about requirements can be obtained up front and that information is fairly stable. Plan-driven models are also considered more suitable for safety- and mission- critical systems because of their emphasis on defect prevention and elimination. Some examples of plan- driven methodologies are the Personal Software Process, the Rational Unified Process, and Cleanroom Software Engineering, agile models are considered to be better suited for projects in which a great deal of change is anticipated. Some examples of agile methodologies are the Extreme Programming (XP) (Beck, 2000), FDD

    Software Intensive Systems (SIS): Software intensive systems (SIS) have become the foundation of virtually every modern technology.

    System engineering

    Software engineering

    Fig 1: Both s/w and system processes are affecting the system

    • Increasing integration of software engineering and system engineering activities

    • Increasing emphasis on users and end-value

    • Increasing SIS criticality and dependability

    • Increasing need to manage rapid change

    • Increasing project/product globalization and need for interoperability

    • Increasing size and complexity

    • Increasing software autonomy

      Technology Innovation: Technological evolution is similar to biological evolution, but occurs at a rate that is orders of magnitude faster, the more capable methods resulting from one stage of evolutionary progress are used to create the next stage.

      Fig 2: Technology evolutions shown in graphs

  2. The Hype Cycle

    Fig 3 :Cycle depicting visibility different parameters

    • technology triggera research breakthrough or launch of an innovative new product that leads to media coverage and public enthusiasm

    • peak of inflated expectationsover-enthusiasm and overly optimistic projections of impact based on limited, but well-publicized successes

    • disillusionmentoverly optimistic projections of impact are not met and critics begin the

      drumbeat; the technology becomes unfashionable among the cognoscenti.

      • slope of enlightenmentgrowing usage by a wide variety of companies leads to a better understanding of the technologys true potential; off the shelf methods and tools emerge to support the technology.

      • plateau of productivityreal world benefits are now obvious and usage penetrates a significant percentage of the potential market

        1. Soft Trends

          • Connectivity and collaboration (enabled by high bandwidth communication) has already led to a software teams that do not occupy the same physical space (telecommuting and part- time employment in a local context).

          • Globalization leads to a diverse workforce (in terms of language, culture, problem resolution, management philosophy, communication priorities, and person-to-person interaction).

          • An aging population implies that many experienced software engineers and managers will be leaving the field over the coming decade. The software engineering community must respond with viable mechanisms that capture the knowledge of these aging managers and technologists

          • Consumer spending in emerging economies will double to well over $9 trillion. There is little doubt that a non-trivial percentage of this spending will be applied to products and services that have a digital componentthat are software-based or software-driven.

        2. Open-World Software

      • Concepts such as ambient intelligence, contextaware applications, and pervasive/ubiquitous computingall focus on integrating software-based systems into an environment far broader than anything to date

      • open-world softwaresoftware that is designed to adapt to a continually changing environment by self-organizing its structure and self-adapting its behavior.

      1. Emergent Requirements

        • As systems become more complex, requirements will emerge as everyone involved in the engineering and construction of a complex system learns more about it, the environment in which it is to reside, and the users who will interact with it.

        • This reality implies a number of software engineering trends. process models must be designed to embrace change and adopt the basic tenets of the agile philosophy methods that yield engineering models (e.g., requirements and design models) must be used judiciously because those models will change repeatedly as more knowledge about the system is acquired tools that support both process and methods must make adaptation and change easy.

      2. The Grand Challenge

        • There is one trend that is undeniablesoftware- based systems will undoubtedly become bigger and more complex as time passes.

        • It is the engineering of these large, complex systems, regardless of delivery platform or application domain, the poses the grand challenge [Bro06] for software engineers.

      3. Key approaches:

        • more effective distributed and collaborative software engineering philosophy

        • better requirements engineering approaches a more robust approach to model-driven development, and better software tools

      4. Collaborative Develoment

        • Today, software engineers collaborate across time zones and international boundaries, and every one of them must share information.

        • The challenge over the next decade is to develop methods and tools that facilitate that collaboration.

      5. Critical success factors:

      • Shared goals

      • Shared culture

      • Shared process

      • Shared responsibility

      Requirements Engineering

      • To improve the manner in which requirements aredefined, the software engineering community will likely implement three distinct sub-processes as RE is conducted [Gli07]

      • improved knowledge acquisition and knowledge sharing that allows more complete understanding of

        application domain constraints and stakeholder needs

      • greater emphasis on iteration as requirements are defined more effective communication and coordination tools that enable all stakeholders to collaborate effectively

        Model-Driven Development

      • couples domain-specific modeling languages with transformation engines and generators in a way that facilitates the representation of abstraction at high levels and then transforms it into lower levels [Sch06]

      • Domain-specific modeling languages (DSMLs) represent application structure, behavior and requirements within particular application domains

      • described with metamodels that define the relationships among concepts in the domain and precisely specify the key semantics and constraints associated with these domain concepts. [Sch06]

        Test-Driven Development

      • In test-driven development (TDD), requirements for a software component serve as the basis for the creation of a series of test cases that exercise the interface and attempt to find errors in the data structures and functionality delivered by the component.TDD is not really a new technology but rather a trend that emphasizes the design of test cases before the creation of source code, continue to emphasize the importance of software architecture.

      Fig 4 :Shows testing phases

  3. Software Engineering Trends



Fig 5:Trends in Software Engg.

  1. SE TrendsProcess:

    Agility Adaptability Collaboration Communication ROI

  2. SE TrendsMethods:

    In RE

    In design

    In languages In testing

    In SCM/SQA

  3. SE TrendsTools:

Project mgmt. Modeling Programming Testing Maintenance SCM


The growing development of dependable software has its own importance. Formal methods in s/w engg is an emerging application of intelligent systems. Deductive s/w verification is a vital technology in formal techniques. Subsequent to this, is s/w synthesizing which is an important base technique of formal methods.

Software verification: It is a formal technique for reasoning about properties of programs. It uses computer assistance for proof search book keeping. It proves validity by deduction in logic calculus. oo use.

Verified s/w consists of programs that are proved error free. Deductive s/w verification is a formal technique for reasoning about properties of programs that has been around 40 years.

Earlier verification of algorithms in academic languages was done, now verification tools support programming languages like java, C#.

Earlier, verification tools used to be stand alone applications used after years of training. Now, tools are there requiring minimal training to use.

Most importantly, deductive verification tools are used as base technology in formal s/w verification and automatic test generation as well. In contrast to static analysis and model checking, can model the semantics of target programming without abstracting from unbounded data structures or programming constructs. The logic In deductive verification are least expensive so it can be formalized and proved far reaching target properties. A recent trend is to insist on automation but to accept approximate results contrast with static analysis and model checking. In logical modeling of programming languages and their semantics, two approaches exist. In the first, target programs appear as separate syntactical category embedded in logical expression. Hoare logic is the best known. Logical rules that characterize the derivability of those formulas that contain programs reflect the target programming languages operational semantics. In the second, target language syntax and semantics are encoded as theories. It involves formalizing data structures like sets, functions, lists, tuples and records.

One major trend is that verification tools attempt to combine formal verification, automatic test generation and automatic bug finding into a uniform framework that is integrated into standard software development platforms like eclipse. The forces behind them are formal verification is too limited and they are at the source code.


  1. System engg and s/w engg integrated together

  2. Rapid change

  3. Increased complex systems of systems

  4. More demand for COTS, reuse and legacy SIS integration

  5. Need for dependability and increased SIS criticality Many trends have been the reason for evolvement of system engg and s/w engg as large sequential and independent processesal systems like ships, railroad

  1. Firstly sys eng begun to determine configuring of various h/w components into physical systems like ships, railroads or defense systems. After this functional components and information requirements

    were specified then external or internal contracts are defined in sequence to produce the components. Secondly, s/w engg is influenced by a highly formal and mathematical approaches for specifying s/w components and a reductionalist approach for deriving computer s/w programs that correctly implemented formal specifications. Thirdly, in places like govt sectors, specification & standards were well placed and were difficult change so purchasing agent concept was followed wherein requirements were sequentially specified, contracts were established, formulated and implementing of solutions was done and requirements were used for acceptance-test solutions.

  2. User-or-organization desire is to have technology that adopts to people rather than vice0versa.Enterprise support packages, data access and mining tools and PDAs are technologies affecting usability and cost effective challenges of this trend is requirements are not prespecified but emerged which are not compatible with past process like requirement driven sequential water fall process models and formal programming calculi.

  3. Other challenge is that dependability is not top priority for s/w products .scaling up and integrating s/w and system dependability so that they cope with future trends challenges like rapid change and agility, globalization, complex system of system and COTS/legacy integration is big hurdle. Examples are AT&T telephone n/ws where high dependability is achieved.

  4. Rapid change increases the priority of developing speed vs cost in capitalizing on market window

    .Hewlett Packards initiative is one of the example to reduce product line s/w development times from 48 to

    12 months, change is driven by trends like Gordan Moores law plus continuing need for product difference and global connectivity accelerates ripple effects of technology, market place and technology changes.

  5. Globalization provides major economies of scale and n/w economies that drive organizations product and process strategies. A standard based infrastructure is essential for effective global collaboration; example is low adoption rate of mire individual/masculine/short term US cultures s/w CMM by organizations in the more collective/feminine/long term that culture.

  6. Systemand software development processes have high risks of inadequate interoperability with other systems. Software intensive systems risks have

    following trends: acquisition management and staffing, requirements/architecture feasibility, achievable software schedules, supplier integration, adoption to rapid change, system and s/w quality factor achievability, product integration and electronic upgrade. To keep software intensive systems of systems destabilized from change of traffic, organize development into plan driven increments(to keep stable from changes).

  7. Infrastructure S/w developers continue to spend most of their time programming and application s/w developers spend in assessing,tailoring and integrating commercial off the shelf (COTS) products.These are challenging to integrate,as they are hard to debug and incompatible with each other.Open source s/w (organizations reused or legacy software) is less opaque.But this to have problems with interoperability and continuing evolution.It put constraints on new applications incremental development.COTS,open source,reused, and legacy s/w and h/w will have shortfalls in dependability and interoperability.IT can be overcome by increasing customer and enterprise architecture initiatives .

  8. In 21st century system and s/w development and evolution, The common modes are business model based user programming, hardware and software product lines, development of unprecedented capabilities, network centric systems of systems. Exploratory development processes will continue to be used in mainstream organizations and in new areas like nanotechnology, advanced biotechnology and robotics, virtual reality and co-operative agent based systems. Business model based user programming address the need to produce more and more s/w capabilities by enabling them to be produced directly by users like spread sheet programs, computer aided design and manufacturing and website development and evolution. Hardware and software product lines includes product lines for transportation, communications, medical, construction, business services, public services and information infrastructure. Network centric systems of systems are highly software intensive and need to be robust, scalable and evolvable in flexible.

  1. Scalable spiral model:

    Adoption of spiral model to the development of software intensive systems of systems in 21st trends have better experiences, based on that there been converging on a scalable process model to scale from small e-services applications to super large defense systems and multi enterprise supply chain managements systems. This model contains familiar

    familiar elements and organizes in new approaches for currents developments.

    Human relations: Earlier human relations emphasize on individual vs team oriented rewards structures and monolithic and not fit with required team oriented, diverse skills .Plan oriented people are drawn towards organization that thrive on order and where in people feel comfortable and empowered if there are clear policies and procedures defining how to succeed. Agile people are drawn towards organizations that thrive on chaos, here people prefer to have fewer policies and procedures and freedom to determine how to succeed. People capability maturity model is best application for 21st trend of human relations that aims on participatory culture, workgroup development, competency development, career development, empowered groups.

    Automatic programming: COBOL compilers were one of the example for automatic programmers, here automatizing the generation of correct-by construction software from formal techniques.

  2. Software Engineering Challenges:

    • Tractable Medium.

      Quite often programmers are also asked to fix hardware product problems because people think that it is cheaper to fix the problems in the (tractable) software than it is to re-design and re-manufacture physical parts. This presents software engineers with the need to design and coding changes, often at the last minute. The software industry has been trying to formulate a sort of scientific/mathematical basis for itself. Formal notations have been proposed to specify a program; mathematical proofs have been defined using these formal notations. The software community is also establishing analysis and design patterns.

    • Changing requirements.

      Adapting for hardware changes is only one source of requirements churn for software engineers. Unfortunately, requirements changes come from many sources. It is often very hard for customers to express exactly what they want in a product .Requirements analysts may not understand the product domain as completely as they need to early in the product lifecycle. As a result, the analysts might not know the right questions to ask the customer to elicit all their requirements. Lastly, the product domain can be constantly changing during the course of a product development cycle. New technology becomes

      available. Competitors release new products that have features that werent thought of. Innovators think

      of wonderful new ideas that will make the product more competitive.

    • Schedule Optimism.

      Software engineers are an optimistic crew. In most organizations, it is the software engineers who estimate how long it will take to develop a product. No matter how many times weve taken longer than we thought in the past, we still believe Next time, things will go more smoothly.We know so much more now

    • Schedule Pressure.

    We often make these aggressive commitments because of the intensity of the people asking us for commitment. It seems that every product is late before its even started, every feature is critical or the business will fold. Products need to be created and updated at a constant, rapid pace lest competitors take over the business.

  3. Conclusion

In this paper we emphasized on recent trends and methods deployed in software engineering streams, by taking into account deductive verification, enhanced spiral model and automatic programming. Future works can be done on improving the testing practice on emerging spiral models and also putting efforts in synchronizing system and software processes. Challenges faced by software product development like varying requirements, Scheduled pressure and scheduled optimism can be worken on it.


[1]Boehm, A spiral model for software development and enhancement, Computer (May 1988), 6172. [2]Beck, Extreme programming explained, Addison Wesley, Reading, MA, 1999.

  1. A. Fuggetta, Software process: A roadmap, The future of software engineering, A. Finkelstein (Editor), ACM Press, 2000.

  2. L. Huang, A value-based process achieving software dependability, Proc Software Process, Workshop 2005, May 2005.

  3. M. Paulk, C. Weber, B. Curtis, and M. Chrissis, The Capability Maturity Model, Addison Wesley, Reading, MA, 1994.

  4. Y. Yang, B. Boehm, and D. Port, A contextualized study of COTS-based e-service projects, Proc Software Process Workshop 2005, Springer, New York, 2005,

  5. Y. Yang, J. Bhuta, D. Port, and B. Boehm, Value- based processes for COTS-based applications, IEEE Software (July/August 2005), 5462.

  6. Intelligent systems and formal methods in software engineering,by Bernhard Beckert.

  7. B. Boehm, A.W. Brown, V. Basili, and R. Turner, Spiral acquisition of software-intensive systems of systems, CrossTalk (May 2004), 49.

Leave a Reply