Course: Iii Bca
1
STUDY MATERIAL
COURSE: III BCA
SEMESTER: V
SUBJECT: SOFTWARE ENGINEERING
UNIT: I
STAFF: R. PANDIAMMAL
SYLLABUS
UNIT-I
Introduction – Definitions – Size factors – Quality and Productivity factors – Planning development process – Planning an Organizational structure.
UNIT-II
Software cost factors-software cost estimation techniques-Staff level Estimating-Estimating software Estimate cost.
UNIT-III
Software Requirement Definition: The Software Requirements specification-Formal Specifications Techniques. Software Design: Fundamental Design concepts-Modules and Modularization Criteria.
Unit-IV
Design Notations-Design Techniques. Implementation Issues: Structured coding Techniques-Coding Style-Standards and Guidelines-Documentation Guideline.
UNIT-V
Verification and Validation Techniques: Quality Assurance-Walkthroughs and Inspections-Unit Testing and Debugging-System testing. Software Maintenance: Enhancing Maintainability during Development-Managerial Aspects of software Maintenance-Configuration Management.
SECITON –A
1. A small project employs one programmer for 1 to 6 months and results in a product containing 1000 to 2000 lines of source code packaged in 25 to 50 routines
2. A project of medium size requires 2 to 5 programmers working for 1 to 2 years and results in a product containing 10,000 to 50,000 lines of source code packaged in 250 to 1000 routines
3. A large project requires 5 to 20 programmers working for 2 to 3 years and results in a product containing 50,000 to 100,000 lines of source code packaged in several subsystems.
4. An extremely very large project employs 2000 to 5000 programmers working for periods of up to 10 years and results in a software system of 1 million to 10 million source instructions
5. The number of communication path among programmers grows as n(n-1)/2 ,where n is the number of programmers on a project team.
6. Utility programs include compilers, assemblers, linkage editors and loaders.
7. Systems programs include data communications packages, real-time process control systems and operating system routines.
SECTION -B
1. Write the Definition of Software engineering.
Software engineering is the technological and managerial discipline concerned with systematic production and maintenance of software products that are developed and modified on time and within cost estimation.
Programmer is an individual who is concerned with the details of implementing, packaging and modifying algorithms and data structures written in a programming language. Software engineers are additionally concerned with issues of analysis, design, verification and testing, documentation, software maintenance, and project management.
2. What is trivial project?
Trivial projects
A trivial software project involves one programmer working, perhaps part time, for a few days or a few weeks and results in a program of less than 500 statements, packaged in 10 to 20 subroutines. Such programs are personal software developed for the exclusive use of the programmer and usually discarded after a few months. There is little need for formal analysis, design, testing and documentation.
3. Define successive versions?
Successive versions
Product development by the methods of successive versions is an extension of prototyping in which an initial product skeleton is refined into increasing levels of capability. In this approach, each successive version of the product is a functioning system capable of performing useful work. The analysis phase followed by iterative design, implementation and assessment of successive versions. The dashed lines indicates that assessment of version I may indicate the need for further analysis before designing version I+1
4. Differentiate quality and quantity goals?
Given a concise statement of the problem and an indication of the constraints that exists for its solution, preliminary goals and requirements can be formulated. Goals are targets for achievement and serve to establish the frame work for a software develop project goals are divided into two a quality goal and quantity goal
A quality process goal: the development process should enhance the professional skills of quality assurance personnel
A quantitative process goal: the system should be delivered within 12 months
A qualitative product goal the system should make users jobs more interesting
A quantitative product goal the system should reduce the cost of a transaction by 25%.some of the quality attributes are explained below.
5. What is a prototype?
A prototype is a mock-up or model of a software product. In contrast to a simulation model, a prototype incorporates components of the actual product. Typically, a prototype exhibits limited functional capabilities, low reliability, and \or inefficient performance. There are several reasons for a developing a prototype .one important reason is to illustrate input data formats, messages, reports, and interactive dialogues for the customer. This is a valuable mechanism for explaining various processing options to the customer and for gaining better understanding of the customers needs.
The second reason for implementing a prototype is to explore technical issues in the proposed product.
The third reason for developing a prototype is in situations where the phased model of analysis, design and implementation is not appropriate. Development of a totally new product will probably involve some prototyping during the planning and analysis phase, or iterating through a series of successive design and implementations may develop the product.
SECTION-C
1. What are the size factors that affect the planning of a software development?
SIZE FACTORS
1. Total Effort Devoted to Software
A major goal of software engineering is to provide tools and techniques to increase the productivity of the available software engineers. Software development involves both hardware and software costs. In 1960 due to the cost of electronic components, the ratio was approximately 80% hardware cost to 20 percent software cost. Now due to latest technology in S/w tools the situation is reversed. Also software maintenance is a large and growing portion of software effort when compared to development.
2. Distribution of Effort
The typical lifespan for a software product is 1 to 3 years in development and 5 to 15 years in use. The distribution of effort between development and maintenance is 0/60, 30/70 and even 10/90.Software maintenance involves 3 types of activities : enhancing the capabilities of the products, adapting the product to new processing environments and correcting bugs and the distribution of effort is 60%,20% and 20% respectively.
Analyze Implement Test Adapt Enhance Fix
and
design
Analysis and design : 40%
Implementation , Debugging and unit testing : 20%
Integration and Acceptance testing : 40%
Project Size Categories
1. Trivial projects
A trivial software project involves one programmer working, perhaps part time , for a few days or a few weeks and results in a program of less than 500 statements, packaged in 10 to 20 subroutines. Such programs are personal software developed for the exclusive use of the programmer and usually discarded after a few months. There is little need for formal analysis, design, testing and documentation.
2. Small projects
A small project employs one programmer for 1 to 6 months and results in a product containing 1000 to 2000 lines of source code packaged in 25 to 50 routines. A small project requires little interaction between programmers or programmers and customers. Standardized techniques and notations, documents and systematic project reviews are used in small projects. Example: scientific applications, small commercial applications and student projects.
3. Medium-size projects
A project of medium size requires 2 to 5 programmers working for 1 to 2 years and results in a product containing 10,000 to 50,000 lines of source code packaged in 250 to 1000 routines. Development of medium size projects requires interaction among programmers and communication with customers. Thus formal planning, documents, and project reviews are required. Eg: programs like assemblers, small MIS, inventory systems and process control applications.
4. Large projects
A large project requires 5 to 20 programmers working for 2 to 3 years and results in a product containing 50,000 to 100,000 lines of source code packaged in several subsystems. Communication problems among programmers, managers and customers are severe on large projects. A large project generally requires more than one programming team and often involves more than one level of management. Eg: large compilers, small time-sharing systems, data-base packages, graphics programs for data acquisition and display, and real-time control systems.
5. Very Large Projects
A very large project requires 100 to 1000 programmers working for 4 to 5 years and results in a software system of 1 million source instructions. A very large system generally consists of several major subsystems, each of which forms a large system. The subsystems have complex interactions with one another and with separately developed systems. Eg: real-time processing, telecommunications and multitasking based programs.
6. Extremely large projects
An extremely very large project employs 2000 to 5000 programmers working for periods of up to 10 years and results in a software system of 1 million to 10 million source instructions. Extremely large systems consist of several very large subsystems and often involve real-time processing, telecommunications, and multitasking and distributed processing. Eg: air traffic control, ballistic missile defense and military command and control systems.
4. State and explain the factors affecting the software quality and productivity.
QUALITY AND PRODUCTIVITY FACTORS
Software quality and programmer productivity can be improved by improving the processes used to develop and maintain software products.
Factors that influence quality and productivity:
1. Individual Ability
Productivity and quality are direct functions of individual ability and effort. There are two aspects to ability: the general competence of the individual and familiarity of the individual with the particular application area. ”General level of competence“means the basic ability to write correct computer programs. The individual difference in programmer productivity should be minimum for a successful product. A better hardware and software tool enables the programmer to maximize the effort.
2. Team communication
Software development is teamwork. Software engineering procedures like design reviews, structured walkthroughs and code-reading exercises have the goals of making software more visible and improving communication among programmers. On the other hand, increasing product size results in decreasing programmer productivity due to increased complexity of interactions among program components and due to increased communication among programmers, managers, and customers. The number of communication path among programmers grows as n(n-1)/2 ,where n is the number of programmers on a project team.
3. Product complexity
There are three acknowledged levels of product complexity: application programs, utility programs, and system-level programs. Application programs include scientific and data processing routines written in a high level language. Utility programs include compilers,assemblers, linkage editors and loaders. Systems programs include data communications packages, real-time process control systems and operating system routines. Application programs have the highest productivity and systems programs the lowest productivity, as measured in lines of code per programmer-day. Utility programs can be produced at a rate 5 to 10 times, and application programs at a rate 25 to 100 times, that of systems programs.
4. Appropriate notations
In software engineering the representation schemes are of fundamental importance. Good notations can clarify the relationships and interactions of interest, while poor notations complicate and interface with good practice. Programming languages provide concise notations for the implementation phase of the software development, but there are no widely accepted notations for stating functional requirements, design specifications, test plans or performance criteria. Appropriate notations provide vehicles of communication among project personnel and introduce the possibility of using automated software tools to manipulate the notations and verify proper usage.
5. Systematic approaches
Various systematic approaches to software development and maintenance are available but many of the procedures and techniques are not yet matured. It is unreasonable to expect that a single approach to software development and maintenance will ever be adequate to cover all situations.
6. Change control
Software must compensate for design deficiencies in the hardware and software is often tailored to satisfy differing requirements of differing customers. Requirements can also change due to poor understating of the problem, or external economic and political factors beyond the control of customer or developer. These changes often become large when the cost of updating requirements, design documents, test plans and user manuals are added. The use of appropriate notations and techniques makes controlled change possible without degrading the quality of work products. he devastating effects of constantly changing requirements can be minimized by planning for change and by controlling the mechanism of change.
7. Level of Technology
The level of technology utilized on a software project accounts for such factors as the programming language, the machine environment, the programming practices and the software tools. Modern programming languages provide improved facilities for data definition and date usage, improved constructs for specifying control flow, better modularization facilities, user defined exception handling and facilities for concurrent programming. The machine environment includes the set of hardware and software facilities available for developing, using and maintaining a software product. Modern programming practices include use of systematic analysis and design techniques, appropriate notations, structured coding, systematic techniques for examining design documents and source code, and systematic testing.
8. Level of reliability
Every software product must possess a basic level of reliability; however, extreme reliability is gained only with great care in analysis, design, implementation, system testing, and maintenance of the software product. The productivity ratio between very low and extremely high-required reliability is in the order of 2:1.
9. Problem Understanding
Several factors contribute to the lack of problem understanding:
- The customer does not truly understand the nature of the problem.
- The customer does not understand the capabilities and limitations of computers.
- The customers are not trained to think in logical and algorithmic terms.
- The software engineer does not understand the application area and has trouble communicating with the customer because of difference in educational backgrounds, view points and technical jargons.
- The customer is not the end user of the system, and the software engineer has no opportunity to investigate user problem.
- The true nature of the problem does not become apparent until the software product is constructed and operated.
Careful planning, customer interviews, task observation, prototyping, a preliminary version of the user manual, and precise product specifications can increase both customer and developer understanding of the problem to be solved.
10. Available time
Software projects are sensitive not only to total effort but also to elapsed time and the number of people involved. Utilizing 6 programmers for 1 month will be less effective than using one programmer for 6 months because the learning curve for six programmers on a 1month schedule will occupy a large percent of elapsed time. On the other hand using 2 programmers for 3 months may be more effective than using one programmer for 6 months due to the reinforcement that each programmer gains from other. The difficulty of the project, the resulting programmer productivity and software quality are sensitive functions of the time available for product development.
11. Required skills
The practice of Software engineering requires lot of skills. Extracting information from customers demands good communication skills, tack, diplomacy as well as knowledge of application area. Requirements definition and design are conceptual in nature and requires good problem-solving skills. Implementation of software requires concentrated attention to details to write the syntax without any errors. Debugging requires deductive skills. Test planning requires consideration of every conceivable situation and stress testing requires a destructive “what if” frame of mind. Preparation of documents requires good writing skills and the ability to place oneself in the user’s position.
12. Facilities and Resources
Good machine access and a quiet place to work are important to a programmer. The positive aspects of a programmer job are creative challenges, variety of tasks, and opportunities for professional advancement, while the negative aspects are management ineptness, company policies and organizational bureaucracy.
13. Adequacy of training
Most entry-level programmers have inability to
- Express oneself clearly in English.
- Develop and validate software requirements and design specifications.
- Work within applications area.
- Perform software maintenance.
- Perform economic analysis.
- Work with project management techniques.
- Work in groups.
It is the job of the Universities to mould their characters. Most software organization gives training to entry-level programmers.
14. Management skills
Managers who have little knowledge of software engineering often supervise software projects. Even managers find project management to be difficult due to differences in design methods, notations and development tools. Many organizations offer project management training to software engineers to prepare them for project management tasks.
15. Appropriate goals
The primary goal of software engineering is development of software products that are appropriate for their intended use. Every software product should provide optimal levels of generality, efficiency and reliability. Increase in programmer productivity may affect product quality. An appropriate trade-off between productivity and quality factors can be achieved by adhering to the goals and requirements established for the software product during project planning.
16. Rising Expectations
There are two interrelated aspects to rising expectations:
How much functionality, reliability, and performance can be provided by a given amount of development effort.
Fundamental limitations of software technology complexity of software applications are growing much faster rate than our ability to cope with the increasing demand. Dramatic advances in hardware technology have created the expectation that software technology will advance at a much faster rate.
5. Draw and explain about system life cycle.
SOFTWARE LIFE CYCLE
