Abstract:

The large enterprise applications, which execute core business applications and keep a company going, are just not a bunch of code modules. They must be structured in a way that enables scalability, security, and robust execution under stressful conditions and their structure (frequently referred to as their architecture) must be defined clearly enough that maintenance programmers can quickly find and fix a bug that shows up long after the original authors have moved on to other projects. That is, these programs must be designed to work perfectly in many areas and business functionality is just one of them, although it certainly is the essential core.

Our approach to Application design is Modeling using ‘standard modeling languages’ like SysML and UML to model just about any type of application, running on any type and combination of hardware, operating system, programming language, and network. By using a model, those responsible for a software development project's success can assure themselves that business functionality is complete and correct and end-user needs are met, program design supports requirements for scalability, robustness, security, extendibility and other characteristics, before implementation in code renders changes difficult and expensive to make.

We will see the different phases of Application design, methodologies used and the deliverables:

Requirements Definition Phase
      System Analysis & Functional Requirements definition
      System Architecture
System Design Phase
     High-Level Design
     Detailed Design
Development and Integration Phase
     Development and Integration
     Test Validation and Implementation

The Requirements are captured from the user and the functional specifications are defined. From the functional specification, the system, the subsystems, the interface between the subsystems and the flow of data and information between the subsystems can be defined using SysML to achieve different functionalities. This Data/Process model can be simulated to verify functionality.

From the system description Software Specifications can be derived. The software specifications can be depicted using UML (use case diagrams) and Test scenarios built using sequence diagrams, which can be used later to test the software against requirements. From the preliminary requirements, the user can have some more derived requirements. The Structure of the software is defined. The behavior can be state driven or data flow. In this whole process the requirements are anchored to the models or elements that implement it, thus requirements can be traced to the design, to the code generated for that software design and the tests performed.

Once the structure and the behavior of the software have been defined it can be executed on the host to test functionality. It can further be downloaded to the target and the models can be animated on the host.

Deliverables:

• System/ Functional Requirements Specification
• System Specification
• Sub System Specification
• System /Sub System Design Description
• Software Requirements Specification
• Software design Description
• Requirements Traceability
• Software Test Plan
• Software Test Coverage